@elizaos/app-core 2.0.3-beta.2 → 2.0.3-beta.3

package/platforms/electrobun/src/index.ts

@@ -2,7 +2,12 @@ import fs from "node:fs";
 import { createServer as createNetServer } from "node:net";
 import os from "node:os";
 import path from "node:path";
-import { resolveApiToken, resolveDesktopApiPort } from "@elizaos/shared";
+import { pathToFileURL } from "node:url";
+import {
+  formatError,
+  resolveApiToken,
+  resolveDesktopApiPort,
+} from "@elizaos/shared";
 import type { BrowserWindow } from "electrobun/bun";
 import Electrobun, {
   ApplicationMenu,
@@ -629,10 +634,23 @@ let surfaceWindowManager: SurfaceWindowManager | null = null;
 let rendererUrlPromise: Promise<string> | null = null;
 let backgroundWindowPromise: Promise<void> | null = null;
 let isQuitting = false;
+let quitRequestPromise: Promise<void> | null = null;
+
+function requestAppQuit(): Promise<void> {
+  if (quitRequestPromise) {
+    return quitRequestPromise;
+  }
 
-function requestAppQuit(): void {
   isQuitting = true;
-  Utils.quit();
+  quitRequestPromise = (async () => {
+    await runShutdownCleanup("explicit-quit").catch((err) => {
+      logger.warn(
+        `[Main] Shutdown cleanup failed before explicit quit: ${formatError(err)}`,
+      );
+    });
+    Utils.quit();
+  })();
+  return quitRequestPromise;
 }
 
 /**
@@ -647,6 +665,7 @@ function isPackagedDesktopBuild(): boolean {
 }
 
 const cleanupFns: Array<() => void | Promise<void>> = [];
+let shutdownCleanupPromise: Promise<void> | null = null;
 let lastFocusedWindow: ManagedWindowLike | null = null;
 const macOpenedDevtoolsWindowIds = new Set<number>();
 
@@ -911,8 +930,12 @@ async function resolveRendererUrl(): Promise<string> {
   }
 
   if (!rendererUrl) {
-    // Last resort: file:// (may have CORS issues with crossorigin module scripts)
-    rendererUrl = `file://${path.join(resolveRendererAssetDir(import.meta.dir), "index.html")}`;
+    // Last resort: file:// (may have CORS issues with crossorigin module scripts).
+    // pathToFileURL builds a valid file:///C:/… URL on Windows; `file://${winPath}`
+    // would be malformed (backslashes, drive letter parsed as host) and not load.
+    rendererUrl = pathToFileURL(
+      path.join(resolveRendererAssetDir(import.meta.dir), "index.html"),
+    ).href;
     logger.warn(
       "[Main] Falling back to file:// renderer URL — CORS issues possible",
     );
@@ -1160,7 +1183,7 @@ function attachMainWindow(
       logger.info(
         "[Main] Window close on Linux with no tray — quitting (no surface to restore from)",
       );
-      requestAppQuit();
+      void requestAppQuit();
       return;
     }
 
@@ -2172,13 +2195,41 @@ function setupDockReopen(): void {
 }
 
 async function runShutdownCleanup(reason: string): Promise<void> {
-  logger.info(`[Main] App quitting (${reason}), disposing native modules...`);
-  isQuitting = true;
-  sendToActiveRenderer("desktopShutdownStarted", { reason });
-  for (const cleanupFn of cleanupFns) {
-    await Promise.resolve(cleanupFn());
+  if (shutdownCleanupPromise) {
+    return shutdownCleanupPromise;
   }
-  await disposeNativeModules();
+
+  shutdownCleanupPromise = (async () => {
+    logger.info(`[Main] App quitting (${reason}), disposing native modules...`);
+    isQuitting = true;
+    sendToActiveRenderer("desktopShutdownStarted", { reason });
+    const cleanupFnsToRun = cleanupFns.splice(0);
+    const cleanupResults = await Promise.allSettled(
+      cleanupFnsToRun.map((cleanupFn) => Promise.resolve().then(cleanupFn)),
+    );
+    for (const result of cleanupResults) {
+      if (result.status === "rejected") {
+        logger.warn(
+          `[Main] Shutdown cleanup callback failed: ${
+            result.reason instanceof Error
+              ? result.reason.message
+              : String(result.reason)
+          }`,
+        );
+      }
+    }
+    try {
+      await disposeNativeModules();
+    } catch (error) {
+      logger.warn(
+        `[Main] Native module disposal failed during shutdown: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  })();
+
+  return shutdownCleanupPromise;
 }
 
 function setupShutdown(): void {
@@ -2632,7 +2683,7 @@ async function main(): Promise<void> {
   });
   getDesktopManager().setRestoreMainWindowCallback(() => restoreWindow());
   getDesktopManager().setRequestQuitCallback(() => {
-    requestAppQuit();
+    void requestAppQuit();
   });
   getDesktopManager().setOpenSurfaceWindowCallback(
     (surface, browse, alwaysOnTop) => {

package/platforms/electrobun/src/lifecycle/api-base-owner.test.ts

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getCurrent, injectIntoHtml, setCurrent } from "./api-base-owner";
+
+const ENV_KEYS = [
+  "ELIZA_STARTUP_SESSION_ID",
+  "ELIZA_STARTUP_STATE_FILE",
+  "ELIZA_STARTUP_EVENTS_FILE",
+  "HOME",
+] as const;
+
+const originalEnv = new Map<string, string | undefined>();
+let tempHome: string | null = null;
+
+beforeEach(() => {
+  for (const key of ENV_KEYS) {
+    originalEnv.set(key, process.env[key]);
+  }
+  tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "eliza-api-base-owner-"));
+  process.env.HOME = tempHome;
+  delete process.env.ELIZA_STARTUP_SESSION_ID;
+  delete process.env.ELIZA_STARTUP_STATE_FILE;
+  delete process.env.ELIZA_STARTUP_EVENTS_FILE;
+  setCurrent(null);
+});
+
+afterEach(() => {
+  setCurrent(null);
+  for (const key of ENV_KEYS) {
+    const value = originalEnv.get(key);
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  originalEnv.clear();
+  if (tempHome) {
+    fs.rmSync(tempHome, { recursive: true, force: true });
+    tempHome = null;
+  }
+});
+
+describe("api-base-owner", () => {
+  it("leaves HTML unchanged without an API base or startup trace id", () => {
+    const html = "<html><head></head><body></body></html>";
+    expect(injectIntoHtml(html)).toBe(html);
+    expect(getCurrent().base).toBeNull();
+  });
+
+  it("injects the host startup trace id before renderer JavaScript runs", () => {
+    process.env.ELIZA_STARTUP_SESSION_ID = "desktop-session-123";
+    const html = "<html><head></head><body></body></html>";
+
+    const injected = injectIntoHtml(html);
+
+    expect(injected).toContain(
+      'window.__ELIZA_STARTUP_TRACE_ID__="desktop-session-123";',
+    );
+    expect(injected).not.toContain("window.__ELIZA_API_BASE__=");
+    expect(injected.indexOf("<script>")).toBeLessThan(
+      injected.indexOf("</head>"),
+    );
+  });
+
+  it("injects startup trace id alongside the current API base snapshot", () => {
+    process.env.ELIZA_STARTUP_SESSION_ID = "desktop-session-456";
+    setCurrent("http://127.0.0.1:31337", "dev-token");
+
+    const injected = injectIntoHtml("<html><head></head><body></body></html>");
+
+    expect(injected).toContain(
+      'window.__ELIZA_STARTUP_TRACE_ID__="desktop-session-456";',
+    );
+    expect(injected).toContain(
+      'window.__ELIZA_API_BASE__="http://127.0.0.1:31337";',
+    );
+    expect(injected).toContain('"__ELIZA_API_TOKEN__"');
+    expect(injected).toContain("elizaos.app.boot-config");
+  });
+});

package/platforms/electrobun/src/lifecycle/api-base-owner.ts

@@ -31,8 +31,10 @@
 
 import {
   pushApiBaseToRenderer,
+  resolveDesktopRuntimeMode,
   resolveDesktopRuntimeModeSignal,
 } from "../api-base";
+import { getStartupTraceConfig } from "../startup-trace";
 
 interface ApiBaseSnapshot {
   base: string | null;
@@ -45,6 +47,10 @@ function safeJsonForHtml(value: unknown): string {
   return JSON.stringify(value).replace(/<\//g, "<\\/");
 }
 
+function resolveStartupTraceId(): string | null {
+  return getStartupTraceConfig().sessionId;
+}
+
 /**
  * Update the singleton with the latest known API base + token. Subsequent
  * `injectIntoHtml(...)` and `pushToWindow(...)` calls read this state.
@@ -78,23 +84,38 @@ export function getCurrent(): Readonly<ApiBaseSnapshot> {
  * apiBase and every `/api/*` call returns SPA HTML.
  */
 export function injectIntoHtml(html: string): string {
-  if (!current.base) return html;
-  const baseLiteral = safeJsonForHtml(current.base);
-  const tokenLiteral = current.token ? safeJsonForHtml(current.token) : "";
-  const tokenInject = tokenLiteral
-    ? `Object.defineProperty(window,"__ELIZA_API_TOKEN__",{value:${tokenLiteral},configurable:true,writable:true,enumerable:false});`
-    : "";
-  const bootConfigInject = `(function(){var k=Symbol.for("elizaos.app.boot-config"),w=window,prev=w.__ELIZAOS_APP_BOOT_CONFIG__||w.__ELIZA_APP_BOOT_CONFIG__||(w[k]&&w[k].current)||{},next=Object.assign({},prev,{apiBase:${baseLiteral}${tokenLiteral ? `,apiToken:${tokenLiteral}` : ""}});w.__ELIZAOS_APP_BOOT_CONFIG__=next;w.__ELIZA_APP_BOOT_CONFIG__=next;w[k]={current:next};})();`;
-  // Desktop cloud-only opt-in: expose the runtime-mode signal as a window global
-  // before any renderer JS runs, so the renderer's cloud-only branding
-  // (shouldUseCloudOnlyBranding) resolves correctly at module-eval time. Only
-  // injected when explicitly cloud, so the default desktop/web behavior is
-  // unchanged.
-  const runtimeModeSignal = resolveDesktopRuntimeModeSignal(process.env);
-  const runtimeModeInject = runtimeModeSignal
-    ? `window.__ELIZA_DESKTOP_RUNTIME_MODE__=${safeJsonForHtml(runtimeModeSignal)};`
+  const startupTraceId = resolveStartupTraceId();
+  const startupTraceInject = startupTraceId
+    ? `window.__ELIZA_STARTUP_TRACE_ID__=${safeJsonForHtml(startupTraceId)};`
     : "";
-  const script = `<script>window.__ELIZA_API_BASE__=${baseLiteral};${runtimeModeInject}${tokenInject}${bootConfigInject}</script>`;
+  if (!current.base && !startupTraceInject) return html;
+
+  let apiBaseInject = "";
+  if (current.base) {
+    const baseLiteral = safeJsonForHtml(current.base);
+    const tokenLiteral = current.token ? safeJsonForHtml(current.token) : "";
+    const tokenInject = tokenLiteral
+      ? `Object.defineProperty(window,"__ELIZA_API_TOKEN__",{value:${tokenLiteral},configurable:true,writable:true,enumerable:false});`
+      : "";
+    const bootConfigInject = `(function(){var k=Symbol.for("elizaos.app.boot-config"),w=window,prev=w.__ELIZAOS_APP_BOOT_CONFIG__||w.__ELIZA_APP_BOOT_CONFIG__||(w[k]&&w[k].current)||{},next=Object.assign({},prev,{apiBase:${baseLiteral}${tokenLiteral ? `,apiToken:${tokenLiteral}` : ""}});w.__ELIZAOS_APP_BOOT_CONFIG__=next;w.__ELIZA_APP_BOOT_CONFIG__=next;w[k]={current:next};})();`;
+    // Desktop cloud-only opt-in: expose the runtime-mode signal as a window global
+    // before any renderer JS runs, so the renderer's cloud-only branding
+    // (shouldUseCloudOnlyBranding) resolves correctly at module-eval time. Only
+    // injected when explicitly cloud, so the default desktop/web behavior is
+    // unchanged.
+    const runtimeModeSignal = resolveDesktopRuntimeModeSignal(process.env);
+    const runtimeModeInject = runtimeModeSignal
+      ? `window.__ELIZA_DESKTOP_RUNTIME_MODE__=${safeJsonForHtml(runtimeModeSignal)};`
+      : "";
+    const runtime = resolveDesktopRuntimeMode(process.env);
+    const externalApiBaseInject =
+      runtime.mode === "external" && runtime.externalApi.base
+        ? `window.__ELIZA_DESKTOP_EXTERNAL_API_BASE__=${safeJsonForHtml(runtime.externalApi.base)};`
+        : "";
+    apiBaseInject = `window.__ELIZA_API_BASE__=${baseLiteral};${runtimeModeInject}${externalApiBaseInject}${tokenInject}${bootConfigInject}`;
+  }
+
+  const script = `<script>${startupTraceInject}${apiBaseInject}</script>`;
   if (html.includes("</head>")) {
     return html.replace("</head>", `${script}</head>`);
   }

package/platforms/electrobun/src/native/agent.ts

@@ -56,7 +56,6 @@ import { logger } from "../logger";
 import { recordStartupPhase, resolveStartupBundlePath } from "../startup-trace";
 import type { SendToWebview } from "../types.js";
 import { findFirstAvailableLoopbackPort } from "./loopback-port";
-import { applyBundledWhisperEnv } from "./whisper-env";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -1271,21 +1270,39 @@ function shouldAutoRecoverPgliteFailure(line: string): boolean {
  * Set ELIZA_AGENT_RECLAIM_STALE_PORT=1 to restore the old "take over default
  * port" behavior.
  */
+/**
+ * PIDs listening on `port`. POSIX uses `lsof`; Windows uses
+ * `Get-NetTCPConnection` (locale-independent and returns the owning PID
+ * directly — `lsof` does not exist on Windows, so the reclaim was a silent
+ * no-op there before).
+ */
+function listListeningPids(port: number): number[] {
+  const result =
+    process.platform === "win32"
+      ? Bun.spawnSync([
+          "powershell.exe",
+          "-NoProfile",
+          "-Command",
+          `(Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue).OwningProcess`,
+        ])
+      : Bun.spawnSync(["lsof", "-ti", `tcp:${port}`]);
+  return new TextDecoder()
+    .decode(result.stdout)
+    .trim()
+    .split(/\r?\n/)
+    .map((p) => parseInt(p.trim(), 10))
+    .filter((n) => !Number.isNaN(n));
+}
+
 async function maybeReclaimPortWithSigkill(port: number): Promise<void> {
   const raw = process.env.ELIZA_AGENT_RECLAIM_STALE_PORT?.trim().toLowerCase();
   if (raw !== "1" && raw !== "true" && raw !== "yes") {
     return;
   }
   try {
-    const lsofResult = Bun.spawnSync(["lsof", "-ti", `tcp:${port}`]);
-    const pids = new TextDecoder()
-      .decode(lsofResult.stdout)
-      .trim()
-      .split("\n")
-      .filter(Boolean);
-    for (const pid of pids) {
-      const numPid = parseInt(pid, 10);
-      if (!Number.isNaN(numPid) && numPid !== process.pid) {
+    const pids = listListeningPids(port);
+    for (const numPid of pids) {
+      if (numPid !== process.pid) {
         diagnosticLog(
           `[Agent] Reclaim: killing process ${numPid} on port ${port} (ELIZA_AGENT_RECLAIM_STALE_PORT)`,
         );
@@ -1300,7 +1317,7 @@ async function maybeReclaimPortWithSigkill(port: number): Promise<void> {
       await new Promise((r) => setTimeout(r, 500));
     }
   } catch {
-    // lsof missing — ignore
+    // port-listing tool missing — ignore
   }
 }
 
@@ -1550,12 +1567,6 @@ export class AgentManager {
         cwd: runtimeDistPath,
       });
       applyDatabaseResolutionToEnv(childEnv, databaseResolution);
-      const bundledWhisper = applyBundledWhisperEnv(childEnv, runtimeDistPath);
-      if (bundledWhisper) {
-        diagnosticLog(
-          `[Agent] Bundled Whisper ASR: ${bundledWhisper.libraryPath}`,
-        );
-      }
       const effectiveTarget =
         databaseResolution.mode === "postgres"
           ? redactDatabaseTarget(databaseResolution.postgresUrl)

package/platforms/electrobun/src/native/credentials.ts

@@ -82,7 +82,12 @@ function isTruthyFlag(value: string | undefined): boolean {
 
 async function isCliInstalled(name: string): Promise<boolean> {
   try {
-    const proc = Bun.spawn(["which", name], {
+    // `which` does not exist on Windows — use `where`. Without this, every CLI
+    // probe (claude, gh, ollama, codex, gemini, gcloud …) spawns a missing
+    // binary, returns false, and the desktop app reports installed CLIs as
+    // absent on Windows.
+    const probe = process.platform === "win32" ? "where" : "which";
+    const proc = Bun.spawn([probe, name], {
       stdout: "pipe",
       stderr: "ignore",
     });

package/platforms/electrobun/src/native/desktop-window.test.ts

@@ -1,9 +1,110 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { DesktopManager, resetDesktopManagerForTesting } from "./desktop";
 
+const electrobunMock = vi.hoisted(() => {
+  type Handler = (event?: unknown) => void;
+  const handlers = new Map<string, Handler[]>();
+  const trayInstances: Array<{
+    on: ReturnType<typeof vi.fn>;
+    off: ReturnType<typeof vi.fn>;
+    remove: ReturnType<typeof vi.fn>;
+    setImage: ReturnType<typeof vi.fn>;
+    setMenu: ReturnType<typeof vi.fn>;
+    setTitle: ReturnType<typeof vi.fn>;
+  }> = [];
+  const events = {
+    on: vi.fn((event: string, handler: Handler) => {
+      const list = handlers.get(event) ?? [];
+      list.push(handler);
+      handlers.set(event, list);
+    }),
+    off: vi.fn((event: string, handler: Handler) => {
+      handlers.set(
+        event,
+        (handlers.get(event) ?? []).filter((item) => item !== handler),
+      );
+    }),
+    emit(event: string, payload?: unknown) {
+      for (const handler of handlers.get(event) ?? []) {
+        handler(payload);
+      }
+    },
+  };
+  const Tray = vi.fn(function FakeTray(this: {
+    on: ReturnType<typeof vi.fn>;
+    off: ReturnType<typeof vi.fn>;
+    remove: ReturnType<typeof vi.fn>;
+    setImage: ReturnType<typeof vi.fn>;
+    setMenu: ReturnType<typeof vi.fn>;
+    setTitle: ReturnType<typeof vi.fn>;
+  }) {
+    this.on = vi.fn();
+    this.off = vi.fn();
+    this.remove = vi.fn();
+    this.setImage = vi.fn();
+    this.setMenu = vi.fn();
+    this.setTitle = vi.fn();
+    trayInstances.push(this);
+  });
+  const Utils = {
+    clipboard: {},
+    openExternal: vi.fn(),
+    paths: {
+      home: "/tmp",
+      appData: "/tmp",
+      userData: "/tmp",
+      userCache: "/tmp",
+      userLogs: "/tmp",
+      temp: "/tmp",
+      cache: "/tmp",
+      logs: "/tmp",
+      config: "/tmp",
+      documents: "/tmp",
+      downloads: "/tmp",
+      desktop: "/tmp",
+      pictures: "/tmp",
+      music: "/tmp",
+      videos: "/tmp",
+    },
+    quit: vi.fn(),
+    showNotification: vi.fn(),
+    showItemInFolder: vi.fn(),
+  };
+  const GlobalShortcut = {
+    isRegistered: vi.fn(() => false),
+    register: vi.fn(),
+    unregister: vi.fn(),
+    unregisterAll: vi.fn(),
+  };
+  return {
+    events,
+    handlers,
+    trayInstances,
+    GlobalShortcut,
+    Tray,
+    Utils,
+    reset() {
+      handlers.clear();
+      trayInstances.splice(0);
+      events.on.mockClear();
+      events.off.mockClear();
+      GlobalShortcut.isRegistered.mockClear();
+      GlobalShortcut.register.mockClear();
+      GlobalShortcut.unregister.mockClear();
+      GlobalShortcut.unregisterAll.mockClear();
+      Tray.mockClear();
+      for (const value of Object.values(Utils)) {
+        if (typeof value === "function" && "mockClear" in value) {
+          value.mockClear();
+        }
+      }
+    },
+  };
+});
+
 vi.mock("electrobun/bun", () => {
   return {
-    default: {},
+    default: { events: electrobunMock.events },
     BrowserView: vi.fn(),
     BuildConfig: {
       appIdentifier: "test.eliza",
@@ -12,38 +113,16 @@ vi.mock("electrobun/bun", () => {
     ContextMenu: {
       on: vi.fn(),
     },
-    GlobalShortcut: vi.fn(),
+    GlobalShortcut: electrobunMock.GlobalShortcut,
     Screen: {
       getAllDisplays: vi.fn(() => []),
     },
     Session: {
       defaultSession: {},
     },
-    Tray: vi.fn(),
+    Tray: electrobunMock.Tray,
     Updater: {},
-    Utils: {
-      clipboard: {},
-      openExternal: vi.fn(),
-      paths: {
-        home: "/tmp",
-        appData: "/tmp",
-        userData: "/tmp",
-        userCache: "/tmp",
-        userLogs: "/tmp",
-        temp: "/tmp",
-        cache: "/tmp",
-        logs: "/tmp",
-        config: "/tmp",
-        documents: "/tmp",
-        downloads: "/tmp",
-        desktop: "/tmp",
-        pictures: "/tmp",
-        music: "/tmp",
-        videos: "/tmp",
-      },
-      showNotification: vi.fn(),
-      showItemInFolder: vi.fn(),
-    },
+    Utils: electrobunMock.Utils,
   };
 });
 
@@ -124,6 +203,7 @@ describe("DesktopManager main window controls", () => {
 
   beforeEach(() => {
     resetDesktopManagerForTesting();
+    electrobunMock.reset();
     delete process.env.ELIZAOS_CLOSE_MINIMIZES_TO_TRAY;
   });
 
@@ -297,4 +377,40 @@ describe("DesktopManager main window controls", () => {
     expect(second.on).toHaveBeenCalledWith("focus", expect.any(Function));
     expect(second.on).toHaveBeenCalledWith("blur", expect.any(Function));
   });
+
+  it("routes tray quit through the app quit callback", async () => {
+    const manager = new DesktopManager();
+    const requestQuit = vi.fn(async () => {});
+    manager.setRequestQuitCallback(requestQuit);
+
+    await manager.createTray({
+      icon: "/tmp/appIcon.png",
+      menu: [{ id: "quit", label: "Quit" }],
+    });
+
+    electrobunMock.events.emit("tray-clicked", {
+      data: { action: "quit" },
+    });
+
+    await vi.waitFor(() => expect(requestQuit).toHaveBeenCalledTimes(1));
+    expect(electrobunMock.Utils.quit).not.toHaveBeenCalled();
+  });
+
+  it("awaits tray teardown during dispose", async () => {
+    const manager = new DesktopManager();
+    await manager.createTray({
+      icon: "/tmp/appIcon.png",
+      menu: [{ id: "quit", label: "Quit" }],
+    });
+    const tray = electrobunMock.trayInstances[0];
+
+    await manager.dispose();
+
+    expect(tray.off).toHaveBeenCalledWith("tray-clicked", expect.any(Function));
+    expect(electrobunMock.events.off).toHaveBeenCalledWith(
+      "tray-clicked",
+      expect.any(Function),
+    );
+    expect(tray.remove).toHaveBeenCalledTimes(1);
+  });
 });

package/platforms/electrobun/src/native/desktop.ts

@@ -730,7 +730,11 @@ export class DesktopManager {
       } else if (action === "restart-agent" || action === "tray-restart") {
         triggerAgentRestart();
       } else if (action === "quit") {
-        Utils.quit();
+        void this.quit().catch((err: unknown) => {
+          logger.warn(
+            `[Desktop] Failed to quit from tray menu: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        });
       } else if (action === "open-settings") {
         this.openSettingsCallback?.();
       }
@@ -2326,7 +2330,7 @@ X-GNOME-Autostart-enabled=true
   /**
    * Clean up all resources.
    */
-  dispose(): void {
+  async dispose(): Promise<void> {
     if (this._focusPoller) {
       clearInterval(this._focusPoller);
       this._focusPoller = null;
@@ -2336,8 +2340,8 @@ X-GNOME-Autostart-enabled=true
     this.releaseNotesView?.remove();
     this.releaseNotesView = null;
     this.releaseNotesWindow = null;
-    this.unregisterAllShortcuts();
-    void this.destroyTray();
+    await this.unregisterAllShortcuts();
+    await this.destroyTray();
     this.trayMenuItems.clear();
     this.sendToWebview = null;
   }

package/platforms/electrobun/src/native/index.ts

@@ -18,6 +18,7 @@ import { getSwabbleManager } from "./swabble";
 import { getTalkModeManager } from "./talkmode";
 
 const NATIVE_DISPOSE_TIMEOUT_MS = 10_000;
+let nativeDisposePromise: Promise<void> | null = null;
 
 export function initializeNativeModules(
   mainWindow: BrowserWindow,
@@ -43,6 +44,11 @@ export function initializeNativeModules(
 }
 
 export async function disposeNativeModules(): Promise<void> {
+  nativeDisposePromise ??= disposeNativeModulesOnce();
+  return nativeDisposePromise;
+}
+
+async function disposeNativeModulesOnce(): Promise<void> {
   const managers = [
     ["agent", getAgentManager()],
     ["browser-workspace", getBrowserWorkspaceManager()],