test: add electron package tests (33 cases)

- prepare-pack: copy/clean behavior, idempotency, missing dirs
- auto-updater: state machine transitions, timer scheduling, throttle
- build: esbuild smoke test, output validation, export verification
- builder-config: YAML structure, path validation, version sync

packages/electron/__tests__/auto-updater.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Tests for electron/auto-updater.ts
+ *
+ * Mocks electron-updater and electron dialog to test state transitions
+ * without a real Electron runtime.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "events";
+
+// ── Mocks ────────────────────────────────────────────────────────────
+
+// Create a mock autoUpdater as an EventEmitter with methods
+const mockAutoUpdater = Object.assign(new EventEmitter(), {
+  autoDownload: true,
+  autoInstallOnAppQuit: false,
+  allowPrerelease: false,
+  checkForUpdates: vi.fn().mockResolvedValue(undefined),
+  downloadUpdate: vi.fn().mockResolvedValue(undefined),
+  quitAndInstall: vi.fn(),
+});
+
+vi.mock("electron-updater", () => ({
+  autoUpdater: mockAutoUpdater,
+}));
+
+vi.mock("electron", () => ({
+  BrowserWindow: class {},
+  dialog: {
+    showMessageBox: vi.fn().mockResolvedValue({ response: 1 }), // "Later" by default
+  },
+}));
+
+// Import after mocks are set up
+const { getAutoUpdateState, initAutoUpdater, stopAutoUpdater } = await import(
+  "../electron/auto-updater.js"
+);
+
+describe("auto-updater state machine", () => {
+  const mockOptions = {
+    getMainWindow: vi.fn().mockReturnValue(null),
+    rebuildTrayMenu: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    mockAutoUpdater.removeAllListeners();
+  });
+
+  afterEach(() => {
+    stopAutoUpdater();
+    vi.useRealTimers();
+  });
+
+  it("initial state is idle", () => {
+    const state = getAutoUpdateState();
+    expect(state.checking).toBe(false);
+    expect(state.updateAvailable).toBe(false);
+    expect(state.downloading).toBe(false);
+    expect(state.downloaded).toBe(false);
+    expect(state.version).toBeNull();
+    expect(state.error).toBeNull();
+  });
+
+  it("configures autoUpdater on init", () => {
+    initAutoUpdater(mockOptions);
+
+    expect(mockAutoUpdater.autoDownload).toBe(false);
+    expect(mockAutoUpdater.autoInstallOnAppQuit).toBe(true);
+    expect(mockAutoUpdater.allowPrerelease).toBe(false);
+  });
+
+  it("schedules initial check after 30s delay", () => {
+    initAutoUpdater(mockOptions);
+
+    expect(mockAutoUpdater.checkForUpdates).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(30_000);
+
+    expect(mockAutoUpdater.checkForUpdates).toHaveBeenCalledTimes(1);
+  });
+
+  it("schedules periodic check every 4 hours", () => {
+    initAutoUpdater(mockOptions);
+
+    // Initial delay
+    vi.advanceTimersByTime(30_000);
+    expect(mockAutoUpdater.checkForUpdates).toHaveBeenCalledTimes(1);
+
+    // 4 hours later
+    vi.advanceTimersByTime(4 * 60 * 60 * 1000);
+    expect(mockAutoUpdater.checkForUpdates).toHaveBeenCalledTimes(2);
+  });
+
+  it("transitions to checking state", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("checking-for-update");
+
+    const state = getAutoUpdateState();
+    expect(state.checking).toBe(true);
+    expect(state.error).toBeNull();
+  });
+
+  it("transitions to update-available state", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("update-available", { version: "2.0.0" });
+
+    const state = getAutoUpdateState();
+    expect(state.checking).toBe(false);
+    expect(state.updateAvailable).toBe(true);
+    expect(state.version).toBe("2.0.0");
+    expect(mockOptions.rebuildTrayMenu).toHaveBeenCalled();
+  });
+
+  it("transitions to update-not-available state", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("checking-for-update");
+    mockAutoUpdater.emit("update-not-available");
+
+    const state = getAutoUpdateState();
+    expect(state.checking).toBe(false);
+    expect(state.updateAvailable).toBe(false);
+  });
+
+  it("tracks download progress", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("download-progress", { percent: 50 });
+
+    const state = getAutoUpdateState();
+    expect(state.downloading).toBe(true);
+    expect(state.progress).toBe(50);
+  });
+
+  it("throttles tray rebuild to every 10% increment", () => {
+    initAutoUpdater(mockOptions);
+    mockOptions.rebuildTrayMenu.mockClear();
+
+    mockAutoUpdater.emit("download-progress", { percent: 5 });
+    expect(mockOptions.rebuildTrayMenu).not.toHaveBeenCalled();
+
+    mockAutoUpdater.emit("download-progress", { percent: 15 });
+    expect(mockOptions.rebuildTrayMenu).toHaveBeenCalledTimes(1);
+
+    mockOptions.rebuildTrayMenu.mockClear();
+    mockAutoUpdater.emit("download-progress", { percent: 20 });
+    expect(mockOptions.rebuildTrayMenu).not.toHaveBeenCalled();
+
+    mockAutoUpdater.emit("download-progress", { percent: 100 });
+    expect(mockOptions.rebuildTrayMenu).toHaveBeenCalledTimes(1);
+  });
+
+  it("transitions to downloaded state", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("update-downloaded", { version: "2.0.0" });
+
+    const state = getAutoUpdateState();
+    expect(state.downloading).toBe(false);
+    expect(state.downloaded).toBe(true);
+    expect(state.progress).toBe(100);
+    expect(mockOptions.rebuildTrayMenu).toHaveBeenCalled();
+  });
+
+  it("handles errors gracefully", () => {
+    initAutoUpdater(mockOptions);
+
+    mockAutoUpdater.emit("error", new Error("Network timeout"));
+
+    const state = getAutoUpdateState();
+    expect(state.checking).toBe(false);
+    expect(state.downloading).toBe(false);
+    expect(state.error).toBe("Network timeout");
+    expect(mockOptions.rebuildTrayMenu).toHaveBeenCalled();
+  });
+
+  it("stopAutoUpdater clears all timers", () => {
+    initAutoUpdater(mockOptions);
+
+    stopAutoUpdater();
+
+    // Advance past both initial delay and periodic interval
+    vi.advanceTimersByTime(5 * 60 * 60 * 1000);
+
+    // checkForUpdates should not have been called (timers cleared)
+    expect(mockAutoUpdater.checkForUpdates).not.toHaveBeenCalled();
+  });
+
+  it("returns a copy of state (not reference)", () => {
+    const state1 = getAutoUpdateState();
+    const state2 = getAutoUpdateState();
+
+    expect(state1).not.toBe(state2);
+    expect(state1).toEqual(state2);
+  });
+});

packages/electron/__tests__/build.test.ts

@@ -0,0 +1,64 @@
+/**
+ * Smoke test for esbuild bundling.
+ *
+ * Verifies that electron/build.mjs produces valid output files
+ * with the expected exports.
+ */
+
+import { describe, it, expect, afterAll } from "vitest";
+import { existsSync, rmSync, statSync } from "fs";
+import { resolve } from "path";
+import { execFileSync } from "child_process";
+
+const PKG_DIR = resolve(import.meta.dirname, "..");
+const DIST = resolve(PKG_DIR, "dist-electron");
+
+describe("electron build (esbuild)", () => {
+  // Build once for all tests in this suite
+  const buildOnce = (() => {
+    let built = false;
+    return () => {
+      if (built) return;
+      execFileSync("node", ["electron/build.mjs"], {
+        cwd: PKG_DIR,
+        timeout: 30_000,
+      });
+      built = true;
+    };
+  })();
+
+  afterAll(() => {
+    // Clean up build output
+    if (existsSync(DIST)) {
+      rmSync(DIST, { recursive: true });
+    }
+  });
+
+  it("produces main.cjs (Electron main process)", () => {
+    buildOnce();
+    const mainCjs = resolve(DIST, "main.cjs");
+    expect(existsSync(mainCjs)).toBe(true);
+    expect(statSync(mainCjs).size).toBeGreaterThan(1000);
+  });
+
+  it("produces server.mjs (backend server bundle)", () => {
+    buildOnce();
+    const serverMjs = resolve(DIST, "server.mjs");
+    expect(existsSync(serverMjs)).toBe(true);
+    expect(statSync(serverMjs).size).toBeGreaterThan(1000);
+  });
+
+  it("produces sourcemaps for both bundles", () => {
+    buildOnce();
+    expect(existsSync(resolve(DIST, "main.cjs.map"))).toBe(true);
+    expect(existsSync(resolve(DIST, "server.mjs.map"))).toBe(true);
+  });
+
+  it("server.mjs exports setPaths and startServer", async () => {
+    buildOnce();
+    const serverMjs = resolve(DIST, "server.mjs");
+    const mod = await import(serverMjs);
+    expect(typeof mod.setPaths).toBe("function");
+    expect(typeof mod.startServer).toBe("function");
+  });
+});

packages/electron/__tests__/builder-config.test.ts

@@ -0,0 +1,130 @@
+/**
+ * Validates electron-builder.yml configuration.
+ *
+ * Ensures all referenced files/directories exist and the config
+ * is structurally valid — catches the kind of path issues that
+ * have historically broken electron releases.
+ */
+
+import { describe, it, expect } from "vitest";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import yaml from "js-yaml";
+
+const PKG_DIR = resolve(import.meta.dirname, "..");
+const ROOT_DIR = resolve(PKG_DIR, "..", "..");
+
+interface BuilderConfig {
+  appId: string;
+  productName: string;
+  electronVersion: string;
+  publish: { provider: string; owner: string; repo: string };
+  directories: { output: string };
+  files: Array<string | { from: string; to: string; filter?: string[] }>;
+  asarUnpack: string[];
+  extraResources: Array<{ from: string; to: string; filter?: string[] }>;
+  win: { target: Array<{ target: string; arch: string[] }>; icon: string };
+  mac: { target: Array<{ target: string; arch: string[] }>; icon: string };
+  linux: { target: Array<{ target: string; arch: string[] }>; icon: string };
+}
+
+const config = yaml.load(
+  readFileSync(resolve(PKG_DIR, "electron-builder.yml"), "utf-8"),
+) as BuilderConfig;
+
+describe("electron-builder.yml", () => {
+  it("has valid YAML structure", () => {
+    expect(config.appId).toBe("com.codex-proxy.app");
+    expect(config.productName).toBe("Codex Proxy");
+    expect(config.electronVersion).toBeDefined();
+  });
+
+  it("has valid publish config", () => {
+    expect(config.publish.provider).toBe("github");
+    expect(config.publish.owner).toBeDefined();
+    expect(config.publish.repo).toBeDefined();
+  });
+
+  it("references existing icon file", () => {
+    const iconPath = resolve(PKG_DIR, config.mac.icon);
+    expect(existsSync(iconPath)).toBe(true);
+  });
+
+  it("icon file is referenced consistently across platforms", () => {
+    expect(config.win.icon).toBe(config.mac.icon);
+    expect(config.linux.icon).toBe(config.mac.icon);
+  });
+
+  it("files list includes dist-electron bundle", () => {
+    const hasDistElectron = config.files.some(
+      (f) => typeof f === "string" && f.includes("dist-electron"),
+    );
+    expect(hasDistElectron).toBe(true);
+  });
+
+  it("files list includes config, public, public-desktop globs", () => {
+    // After prepare-pack copies root dirs into packages/electron/,
+    // electron-builder picks them up via simple glob patterns
+    const globs = config.files.filter((f): f is string => typeof f === "string");
+    expect(globs).toContain("config/**/*");
+    expect(globs).toContain("public/**/*");
+    expect(globs).toContain("public-desktop/**/*");
+  });
+
+  it("root source directories for prepare-pack actually exist", () => {
+    // prepare-pack.mjs copies these from root before packing
+    const requiredDirs = ["config", "public", "bin"];
+    for (const dir of requiredDirs) {
+      const rootPath = resolve(ROOT_DIR, dir);
+      expect(
+        existsSync(rootPath),
+        `Root directory ${dir}/ should exist at ${rootPath}`,
+      ).toBe(true);
+    }
+  });
+
+  it("extraResources bin/ maps to correct root directory", () => {
+    const binResource = config.extraResources.find(
+      (r) => r.to === "bin/" || r.to === "bin",
+    );
+    expect(binResource).toBeDefined();
+    // bin/ is copied from root by prepare-pack before packing
+    const rootBin = resolve(ROOT_DIR, "bin");
+    expect(
+      existsSync(rootBin),
+      `Root bin/ directory should exist at ${rootBin}`,
+    ).toBe(true);
+  });
+
+  it("asarUnpack includes all runtime directories", () => {
+    const unpacked = config.asarUnpack;
+    expect(unpacked).toContain("config/**/*");
+    expect(unpacked).toContain("public/**/*");
+    expect(unpacked).toContain("public-desktop/**/*");
+  });
+
+  it("electronVersion matches installed version", () => {
+    const installedPkg = resolve(
+      ROOT_DIR,
+      "node_modules",
+      "electron",
+      "package.json",
+    );
+    if (existsSync(installedPkg)) {
+      const installed = JSON.parse(readFileSync(installedPkg, "utf-8")) as {
+        version: string;
+      };
+      expect(config.electronVersion).toBe(installed.version);
+    }
+  });
+
+  it("package.json has required fields for electron-builder", () => {
+    const pkg = JSON.parse(
+      readFileSync(resolve(PKG_DIR, "package.json"), "utf-8"),
+    ) as Record<string, unknown>;
+    expect(pkg.name).toBeDefined();
+    expect(pkg.version).toBeDefined();
+    expect(pkg.description).toBeDefined();
+    expect(pkg.main).toBe("dist-electron/main.cjs");
+  });
+});

packages/electron/__tests__/prepare-pack.test.ts

@@ -0,0 +1,97 @@
+/**
+ * Tests for electron/prepare-pack.mjs
+ *
+ * Verifies that root-level resources (config/, public/, etc.) are correctly
+ * copied into packages/electron/ before electron-builder runs, and cleaned
+ * up afterward.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { existsSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { execFileSync } from "child_process";
+
+const PKG_DIR = resolve(import.meta.dirname, "..");
+const ROOT_DIR = resolve(PKG_DIR, "..", "..");
+const SCRIPT = resolve(PKG_DIR, "electron", "prepare-pack.mjs");
+
+// Directories that prepare-pack copies from root into packages/electron/
+const DIRS = ["config", "public", "public-desktop", "bin"];
+
+describe("prepare-pack.mjs", () => {
+  // Clean up any leftover copies before/after each test
+  function cleanCopies(): void {
+    for (const dir of DIRS) {
+      const dest = resolve(PKG_DIR, dir);
+      // Only remove if it's a copy (not the root original)
+      if (existsSync(dest) && resolve(dest) !== resolve(ROOT_DIR, dir)) {
+        rmSync(dest, { recursive: true });
+      }
+    }
+  }
+
+  beforeEach(cleanCopies);
+  afterEach(cleanCopies);
+
+  it("copies root directories into packages/electron/", () => {
+    execFileSync("node", [SCRIPT], { cwd: PKG_DIR });
+
+    for (const dir of DIRS) {
+      const rootDir = resolve(ROOT_DIR, dir);
+      const copyDir = resolve(PKG_DIR, dir);
+      if (existsSync(rootDir)) {
+        expect(existsSync(copyDir)).toBe(true);
+      }
+    }
+  });
+
+  it("copies config/ with correct content", () => {
+    execFileSync("node", [SCRIPT], { cwd: PKG_DIR });
+
+    const rootConfig = resolve(ROOT_DIR, "config", "default.yaml");
+    const copyConfig = resolve(PKG_DIR, "config", "default.yaml");
+
+    if (existsSync(rootConfig)) {
+      expect(existsSync(copyConfig)).toBe(true);
+      expect(readFileSync(copyConfig, "utf-8")).toBe(
+        readFileSync(rootConfig, "utf-8"),
+      );
+    }
+  });
+
+  it("--clean removes copied directories", () => {
+    // First copy
+    execFileSync("node", [SCRIPT], { cwd: PKG_DIR });
+
+    // Verify at least config exists
+    const copyConfig = resolve(PKG_DIR, "config");
+    expect(existsSync(copyConfig)).toBe(true);
+
+    // Then clean
+    execFileSync("node", [SCRIPT, "--clean"], { cwd: PKG_DIR });
+
+    for (const dir of DIRS) {
+      expect(existsSync(resolve(PKG_DIR, dir))).toBe(false);
+    }
+  });
+
+  it("skips missing root directories without error", () => {
+    // Create a temp directory that doesn't have all root dirs
+    // The script should warn but not throw
+    const result = execFileSync("node", [SCRIPT], {
+      cwd: PKG_DIR,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    // Should succeed without throwing
+    expect(result).toBeDefined();
+  });
+
+  it("--clean is idempotent (no error when dirs already absent)", () => {
+    // Clean without prior copy — should not throw
+    expect(() => {
+      execFileSync("node", [SCRIPT, "--clean"], { cwd: PKG_DIR });
+    }).not.toThrow();
+  });
+});

vitest.config.ts

@@ -16,6 +16,7 @@ export default defineConfig({
       "tests/unit/**/*.{test,spec}.ts",
       "tests/integration/**/*.{test,spec}.ts",
       "tests/e2e/**/*.{test,spec}.ts",
+      "packages/electron/__tests__/**/*.{test,spec}.ts",
     ],
   },
 });