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

package/platforms/electrobun/src/native/webgpu-browser-support.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { checkWebGpuSupport } from "./webgpu-browser-support";
+
+describe("webgpu browser support", () => {
+  it("reports CEF-specific requirements when CEF is active", () => {
+    const status = checkWebGpuSupport("cef");
+
+    expect(status.renderer).toBe("cef");
+    expect(status.reason).toContain("CEF needs WebGPU-related Chromium flags");
+  });
+
+  it("reports native renderer support without falling back to unknown", () => {
+    const status = checkWebGpuSupport("native");
+
+    expect(status.renderer).toBe("native");
+    expect(status.reason).not.toContain("Unable to determine");
+  });
+});

package/platforms/electrobun/src/native/webgpu-browser-support.ts

@@ -4,99 +4,99 @@ import * as path from "node:path";
 import { getBrandConfig } from "../brand-config";
 
 export interface WebGpuSupportStatus {
-	/** Whether WebGPU is expected to be available in the webview renderer. */
-	available: boolean;
-	/** Human-readable explanation of the status. */
-	reason: string;
-	/** Which renderer backend is active (native = WKWebView, cef = Chromium). */
-	renderer: "native" | "cef" | "unknown";
-	/** Path to Chrome Beta if found on disk. */
-	chromeBetaPath: string | null;
-	/** URL to download Chrome Beta for this platform. */
-	downloadUrl: string | null;
+  /** Whether WebGPU is expected to be available in the webview renderer. */
+  available: boolean;
+  /** Human-readable explanation of the status. */
+  reason: string;
+  /** Which renderer backend is active (native = WKWebView, cef = Chromium). */
+  renderer: "native" | "cef" | "unknown";
+  /** Path to Chrome Beta if found on disk. */
+  chromeBetaPath: string | null;
+  /** URL to download Chrome Beta for this platform. */
+  downloadUrl: string | null;
 }
 
 export interface ChromeBetaDetection {
-	/** Whether Chrome Beta was found on disk. */
-	found: boolean;
-	/** Absolute path to the Chrome Beta executable, or null. */
-	path: string | null;
-	/** Platform-specific download URL for Chrome Beta. */
-	downloadUrl: string;
+  /** Whether Chrome Beta was found on disk. */
+  found: boolean;
+  /** Absolute path to the Chrome Beta executable, or null. */
+  path: string | null;
+  /** Platform-specific download URL for Chrome Beta. */
+  downloadUrl: string;
 }
 
 const CHROME_BETA_PATHS: Record<string, string[]> = {
-	darwin: [
-		"/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
-	],
-	linux: [
-		"/usr/bin/google-chrome-beta",
-		"/opt/google/chrome-beta/google-chrome-beta",
-	],
-	win32: [
-		// %LOCALAPPDATA%\Google\Chrome Beta\Application\chrome.exe
-		path.join(
-			process.env.LOCALAPPDATA ?? "",
-			"Google",
-			"Chrome Beta",
-			"Application",
-			"chrome.exe",
-		),
-		// Fallback for x86 program files
-		path.join(
-			process.env.PROGRAMFILES ?? "C:\\Program Files",
-			"Google",
-			"Chrome Beta",
-			"Application",
-			"chrome.exe",
-		),
-		path.join(
-			process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)",
-			"Google",
-			"Chrome Beta",
-			"Application",
-			"chrome.exe",
-		),
-	],
+  darwin: [
+    "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta",
+  ],
+  linux: [
+    "/usr/bin/google-chrome-beta",
+    "/opt/google/chrome-beta/google-chrome-beta",
+  ],
+  win32: [
+    // %LOCALAPPDATA%\Google\Chrome Beta\Application\chrome.exe
+    path.join(
+      process.env.LOCALAPPDATA ?? "",
+      "Google",
+      "Chrome Beta",
+      "Application",
+      "chrome.exe",
+    ),
+    // Fallback for x86 program files
+    path.join(
+      process.env.PROGRAMFILES ?? "C:\\Program Files",
+      "Google",
+      "Chrome Beta",
+      "Application",
+      "chrome.exe",
+    ),
+    path.join(
+      process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)",
+      "Google",
+      "Chrome Beta",
+      "Application",
+      "chrome.exe",
+    ),
+  ],
 };
 
 const CHROME_BETA_DOWNLOAD_URLS: Record<string, string> = {
-	darwin: "https://www.google.com/chrome/beta/",
-	linux: "https://www.google.com/chrome/beta/",
-	win32: "https://www.google.com/chrome/beta/",
+  darwin: "https://www.google.com/chrome/beta/",
+  linux: "https://www.google.com/chrome/beta/",
+  win32: "https://www.google.com/chrome/beta/",
 };
 
 /**
  * Locate Chrome Beta on the current platform.
  */
 export function detectChromeBeta(): ChromeBetaDetection {
-	const platform = process.platform;
-	const candidates = CHROME_BETA_PATHS[platform] ?? [];
-	const downloadUrl =
-		CHROME_BETA_DOWNLOAD_URLS[platform] ??
-		"https://www.google.com/chrome/beta/";
-
-	for (const candidate of candidates) {
-		try {
-			if (fs.existsSync(candidate)) {
-				return { found: true, path: candidate, downloadUrl };
-			}
-		} catch {
-			// Permission errors etc. — try next candidate
-		}
-	}
-
-	return { found: false, path: null, downloadUrl };
+  const platform = process.platform;
+  const candidates = CHROME_BETA_PATHS[platform] ?? [];
+  const downloadUrl =
+    CHROME_BETA_DOWNLOAD_URLS[platform] ??
+    "https://www.google.com/chrome/beta/";
+
+  for (const candidate of candidates) {
+    try {
+      if (fs.existsSync(candidate)) {
+        return { found: true, path: candidate, downloadUrl };
+      }
+    } catch {
+      // Permission errors etc. — try next candidate
+    }
+  }
+
+  return { found: false, path: null, downloadUrl };
 }
 
 /**
  * Returns the platform-specific download URL for Chrome Beta.
  */
 export function getChromeBetaDownloadUrl(): string {
-	return (
-		CHROME_BETA_DOWNLOAD_URLS[process.platform] ??
-		"https://www.google.com/chrome/beta/"
-	);
+  return (
+    CHROME_BETA_DOWNLOAD_URLS[process.platform] ??
+    "https://www.google.com/chrome/beta/"
+  );
 }
 
 /**
@@ -105,14 +105,14 @@ export function getChromeBetaDownloadUrl(): string {
  * not use Chromium flags.
  */
 export function getWebGpuChromiumFlags(): string[] {
-	const flags = ["--enable-unsafe-webgpu"];
+  const flags = ["--enable-unsafe-webgpu"];
 
-	if (process.platform === "linux") {
-		flags.push("--enable-features=Vulkan");
-		flags.push("--use-angle=vulkan");
-	}
+  if (process.platform === "linux") {
+    flags.push("--enable-features=Vulkan");
+    flags.push("--use-angle=vulkan");
+  }
 
-	return flags;
+  return flags;
 }
 
 /**
@@ -139,21 +139,21 @@ export function getWebGpuChromiumFlags(): string[] {
  * Darwin majors below 20 (macOS 10.x and earlier): returns `null` (not needed for WebGPU).
  */
 export function getMacOSMajorVersion(): number | null {
-	if (process.platform !== "darwin") return null;
-	try {
-		const release = os.release(); // e.g. "25.0.0" on macOS 26 (Darwin 25)
-		const darwinMajor = Number.parseInt(release.split(".")[0], 10);
-		if (Number.isNaN(darwinMajor)) return null;
-		if (darwinMajor >= 25) {
-			return darwinMajor + 1;
-		}
-		if (darwinMajor >= 20) {
-			return darwinMajor - 9;
-		}
-		return null;
-	} catch {
-		return null;
-	}
+  if (process.platform !== "darwin") return null;
+  try {
+    const release = os.release(); // e.g. "25.0.0" on macOS 26 (Darwin 25)
+    const darwinMajor = Number.parseInt(release.split(".")[0], 10);
+    if (Number.isNaN(darwinMajor)) return null;
+    if (darwinMajor >= 25) {
+      return darwinMajor + 1;
+    }
+    if (darwinMajor >= 20) {
+      return darwinMajor - 9;
+    }
+    return null;
+  } catch {
+    return null;
+  }
 }
 
 /**
@@ -162,59 +162,77 @@ export function getMacOSMajorVersion(): number | null {
  * @param rendererType - The active renderer ("native" for WKWebView, "cef" for Chromium)
  */
 export function checkWebGpuSupport(
-	rendererType: "native" | "cef" = process.platform === "darwin"
-		? "native"
-		: "cef",
+  rendererType: "native" | "cef" = process.platform === "darwin"
+    ? "native"
+    : "cef",
 ): WebGpuSupportStatus {
-	const chromeBeta = detectChromeBeta();
-
-	// macOS with WKWebView (native renderer)
-	if (process.platform === "darwin" && rendererType === "native") {
-		const macVersion = getMacOSMajorVersion();
-
-		if (macVersion !== null && macVersion >= 26) {
-			return {
-				available: true,
-				reason:
-					"WebGPU is natively supported in WKWebView on macOS 26+ (Tahoe).",
-				renderer: "native",
-				chromeBetaPath: chromeBeta.path,
-				downloadUrl: null,
-			};
-		}
-
-		// macOS < 26 — WKWebView doesn't expose WebGPU (the app still runs; UI uses WebGL).
-		return {
-			available: false,
-			reason: `WKWebView does not expose WebGPU on macOS ${macVersion ?? "unknown"} (native navigator.gpu needs macOS 26+ Tahoe). ${getBrandConfig().appName} still runs; companion and avatar use WebGL when WebGPU is missing. Chrome Beta is optional for separate Chromium WebGPU experiments.`,
-			renderer: "native",
-			chromeBetaPath: chromeBeta.path,
-			downloadUrl: chromeBeta.downloadUrl,
-		};
-	}
-
-	// Linux / Windows with CEF
-	if (rendererType === "cef") {
-		// CEF needs --enable-unsafe-webgpu which we can't inject yet
-		// (upstream Electrobun feature needed)
-		const flags = getWebGpuChromiumFlags();
-		const flagList = flags.join(", ");
-
-		return {
-			available: false,
-			reason: `CEF needs WebGPU-related Chromium flags (${flagList}); injecting them from ${getBrandConfig().appName} is pending upstream Electrobun support. ${chromeBeta.found ? "Chrome Beta is installed for optional WebGPU testing." : "Chrome Beta is not installed."} The ${getBrandConfig().appName} UI still runs on WebGL when the renderer has no WebGPU.`,
-			renderer: "cef",
-			chromeBetaPath: chromeBeta.path,
-			downloadUrl: chromeBeta.found ? null : chromeBeta.downloadUrl,
-		};
-	}
-
-	// Unknown / fallback
-	return {
-		available: false,
-		reason: `Unable to determine WebGPU support for this configuration. ${getBrandConfig().appName} still runs; the UI uses WebGL when WebGPU is unavailable.`,
-		renderer: "unknown",
-		chromeBetaPath: chromeBeta.path,
-		downloadUrl: chromeBeta.downloadUrl,
-	};
+  const chromeBeta = detectChromeBeta();
+
+  // macOS with WKWebView (native renderer)
+  if (process.platform === "darwin" && rendererType === "native") {
+    const macVersion = getMacOSMajorVersion();
+
+    if (macVersion !== null && macVersion >= 26) {
+      return {
+        available: true,
+        reason:
+          "WebGPU is natively supported in WKWebView on macOS 26+ (Tahoe).",
+        renderer: "native",
+        chromeBetaPath: chromeBeta.path,
+        downloadUrl: null,
+      };
+    }
+
+    // macOS < 26 — WKWebView doesn't expose WebGPU (the app still runs; UI uses WebGL).
+    return {
+      available: false,
+      reason: `WKWebView does not expose WebGPU on macOS ${macVersion ?? "unknown"} (native navigator.gpu needs macOS 26+ Tahoe). ${getBrandConfig().appName} still runs; companion and avatar use WebGL when WebGPU is missing. Chrome Beta is optional for separate Chromium WebGPU experiments.`,
+      renderer: "native",
+      chromeBetaPath: chromeBeta.path,
+      downloadUrl: chromeBeta.downloadUrl,
+    };
+  }
+
+  // Linux / Windows with CEF
+  if (rendererType === "cef") {
+    const flags = getWebGpuChromiumFlags();
+    const flagList = flags.join(", ");
+    const linuxOptInHint =
+      process.platform === "linux"
+        ? " Linux CEF WebGPU/Vulkan flags are disabled by default for desktop stability; set ELIZA_ELECTROBUN_ENABLE_CEF_WEBGPU=1 to opt into hardware WebGPU experiments."
+        : "";
+
+    return {
+      available: false,
+      reason: `CEF needs WebGPU-related Chromium flags (${flagList}).${linuxOptInHint} ${chromeBeta.found ? "Chrome Beta is installed for optional WebGPU testing." : "Chrome Beta is not installed."} The ${getBrandConfig().appName} UI still runs on WebGL when the renderer has no WebGPU.`,
+      renderer: "cef",
+      chromeBetaPath: chromeBeta.path,
+      downloadUrl: chromeBeta.found ? null : chromeBeta.downloadUrl,
+    };
+  }
+
+  if (rendererType === "native") {
+    const nativeRendererName =
+      process.platform === "linux"
+        ? "WebKitGTK"
+        : process.platform === "win32"
+          ? "platform-native webview"
+          : "native webview";
+    return {
+      available: false,
+      reason: `${getBrandConfig().appName} is using the ${nativeRendererName} renderer; browser WebGPU is not expected in this renderer. The UI still runs on WebGL when WebGPU is unavailable.`,
+      renderer: "native",
+      chromeBetaPath: chromeBeta.path,
+      downloadUrl: chromeBeta.downloadUrl,
+    };
+  }
+
+  // Unknown / fallback
+  return {
+    available: false,
+    reason: `Unable to determine WebGPU support for this configuration. ${getBrandConfig().appName} still runs; the UI uses WebGL when WebGPU is unavailable.`,
+    renderer: "unknown",
+    chromeBetaPath: chromeBeta.path,
+    downloadUrl: chromeBeta.downloadUrl,
+  };
 }

package/platforms/electrobun/src/native-onboarding.ts

@@ -0,0 +1,270 @@
+/**
+ * Native macOS notification–driven onboarding flow.
+ *
+ * Instead of opening a BrowserWindow for onboarding, this module:
+ * 1. Posts a native macOS notification with action buttons
+ *    ("Local (On-Device)", "Local (Cloud AI)", "Eliza Cloud")
+ * 2. Polls for the user's choice via FFI
+ * 3. Calls the local first-run API to complete onboarding
+ *
+ * This runs entirely in the main process — no renderer needed for the choice.
+ * After the first-run API responds, the caller opens the dashboard.
+ */
+
+import {
+  DEFAULT_ELIZA_CLOUD_TEXT_MODEL,
+  getDefaultStylePreset,
+} from "@elizaos/shared";
+import { buildFirstRunRuntimeConfig } from "../../../src/first-run/first-run-config";
+import { logger } from "./logger";
+import {
+  dismissOnboardingNotification,
+  getOnboardingChoice,
+  type OnboardingChoice,
+  postOnboardingNotification,
+} from "./native/mac-window-effects";
+
+/**
+ * Resolved user choice from the notification, mapped to the runtime fields
+ * understood by the first-run API.
+ */
+export interface ResolvedOnboardingChoice {
+  runtime: "local" | "cloud";
+  localInference: "all-local" | "cloud-inference";
+}
+
+/** Maximum number of times the notification is re-posted when dismissed. */
+const MAX_DISMISS_RETRIES = 3;
+
+/**
+ * Post the onboarding notification and poll until the user picks an action.
+ * Returns `null` if the notification could not be posted (e.g. non-macOS),
+ * the user dismissed it more than MAX_DISMISS_RETRIES times (falls back to
+ * the overlay), or an unrecognised choice is received.
+ *
+ * @param dismissRetryCount - internal recursion depth guard; callers should
+ *   omit this (defaults to 0). When it reaches MAX_DISMISS_RETRIES the
+ *   function returns null so the caller can fall back to the onboarding
+ *   overlay rather than looping indefinitely.
+ */
+export async function waitForOnboardingNotificationChoice(
+  dismissRetryCount = 0,
+): Promise<ResolvedOnboardingChoice | null> {
+  const posted = postOnboardingNotification(
+    "Welcome to Eliza",
+    "Choose how to run your agent.",
+  );
+  if (!posted) {
+    logger.warn(
+      "[native-onboarding] Failed to post notification — falling back to overlay",
+    );
+    return null;
+  }
+  logger.info("[native-onboarding] Notification posted, waiting for choice…");
+
+  // Maximum time to wait for a user choice before giving up (5 minutes).
+  // This ensures the setInterval is always cleared even if the promise is
+  // abandoned (e.g. the overlay wins the race and the notification is ignored).
+  const POLL_TIMEOUT_MS = 5 * 60 * 1_000;
+
+  return new Promise<ResolvedOnboardingChoice | null>((resolve) => {
+    let settled = false;
+    const settle = (
+      value:
+        | ResolvedOnboardingChoice
+        | null
+        | PromiseLike<ResolvedOnboardingChoice | null>,
+    ): void => {
+      if (settled) return;
+      settled = true;
+      clearInterval(timer);
+      clearTimeout(abandonTimeout);
+      // resolve() is Promise/A+ compliant — passing a PromiseLike chains it.
+      resolve(value);
+    };
+
+    const timer = setInterval(() => {
+      const choice: OnboardingChoice = getOnboardingChoice();
+      if (choice === 0) return; // still waiting
+
+      // Dismiss the notification for all choice paths so macOS removes it
+      // from the notification centre before we settle/re-post.
+      dismissOnboardingNotification();
+
+      switch (choice) {
+        case 1: // Local (On-Device)
+          logger.info("[native-onboarding] User chose: local all-on-device");
+          settle({ runtime: "local", localInference: "all-local" });
+          break;
+        case 2: // Local (Cloud AI)
+          logger.info("[native-onboarding] User chose: local cloud-inference");
+          settle({ runtime: "local", localInference: "cloud-inference" });
+          break;
+        case 3: // Eliza Cloud
+          logger.info("[native-onboarding] User chose: Eliza Cloud");
+          settle({ runtime: "cloud", localInference: "all-local" });
+          break;
+        case 4: // Dismissed
+          if (dismissRetryCount >= MAX_DISMISS_RETRIES) {
+            logger.warn(
+              `[native-onboarding] Notification dismissed ${MAX_DISMISS_RETRIES + 1} times — falling back to overlay`,
+            );
+            settle(null);
+          } else {
+            logger.info(
+              `[native-onboarding] Notification dismissed (retry ${dismissRetryCount + 1}/${MAX_DISMISS_RETRIES}) — re-posting`,
+            );
+            settle(waitForOnboardingNotificationChoice(dismissRetryCount + 1));
+          }
+          break;
+        default:
+          settle(null);
+      }
+    }, 500);
+
+    // Safety net: if the promise is abandoned (overlay wins the race or the
+    // caller is GC-ed) this timeout clears the interval so we don't leak.
+    const abandonTimeout = setTimeout(() => {
+      if (!settled) {
+        logger.warn(
+          "[native-onboarding] Timed out waiting for notification choice — clearing poll timer",
+        );
+        settle(null);
+      }
+    }, POLL_TIMEOUT_MS);
+  });
+}
+
+/**
+ * Build the first-run submit payload and POST it to the local API server.
+ *
+ * This mirrors what the renderer does in `finishLocal` / `finishCloud`,
+ * but runs entirely from the main process so no renderer window is needed.
+ */
+export async function submitOnboardingFirstRun(
+  apiBase: string,
+  choice: ResolvedOnboardingChoice,
+): Promise<boolean> {
+  const style = getDefaultStylePreset();
+  const agentName = style.name;
+
+  const runtimeTarget =
+    choice.runtime === "cloud"
+      ? "elizacloud"
+      : choice.localInference === "cloud-inference"
+        ? "elizacloud-hybrid"
+        : "local";
+
+  const provider =
+    choice.runtime === "cloud" || choice.localInference === "cloud-inference"
+      ? "elizacloud"
+      : "";
+
+  const useCloudModels =
+    choice.runtime === "cloud" || choice.localInference === "cloud-inference";
+  const cloudModel = useCloudModels ? DEFAULT_ELIZA_CLOUD_TEXT_MODEL : "";
+
+  const runtimeConfig = buildFirstRunRuntimeConfig({
+    firstRunRuntimeTarget: runtimeTarget,
+    firstRunCloudApiKey: "",
+    firstRunProvider: provider,
+    firstRunApiKey: "",
+    omitRuntimeProvider: provider !== "elizacloud",
+    firstRunVoiceProvider: "",
+    firstRunVoiceApiKey: "",
+    firstRunPrimaryModel: "",
+    firstRunOpenRouterModel: "",
+    firstRunRemoteConnected: false,
+    firstRunRemoteApiBase: "",
+    firstRunRemoteToken: "",
+    firstRunNanoModel: cloudModel,
+    firstRunSmallModel: cloudModel,
+    firstRunMediumModel: cloudModel,
+    firstRunLargeModel: cloudModel,
+    firstRunMegaModel: cloudModel,
+    firstRunFeatureCrypto: true,
+    firstRunFeatureBrowser: true,
+  });
+
+  const systemPrompt =
+    style.system?.replace(/\{\{name\}\}/g, agentName) ??
+    `You are ${agentName}, an autonomous AI agent powered by elizaOS.`;
+
+  const payload = {
+    name: agentName,
+    sandboxMode: choice.runtime === "cloud" ? "standard" : "off",
+    bio: style.bio ?? ["An autonomous AI agent."],
+    systemPrompt,
+    style: style.style,
+    adjectives: style.adjectives,
+    topics: style.topics,
+    postExamples: style.postExamples,
+    messageExamples: style.messageExamples,
+    avatarIndex: style.avatarIndex ?? 1,
+    language: "en",
+    presetId: style.id,
+    deploymentTarget: runtimeConfig.deploymentTarget,
+    ...(runtimeConfig.linkedAccounts
+      ? { linkedAccounts: runtimeConfig.linkedAccounts }
+      : {}),
+    ...(runtimeConfig.serviceRouting
+      ? { serviceRouting: runtimeConfig.serviceRouting }
+      : {}),
+    ...(runtimeConfig.credentialInputs
+      ? { credentialInputs: runtimeConfig.credentialInputs }
+      : {}),
+    features: {
+      crypto: { enabled: true },
+      browser: { enabled: true },
+      voice: { enabled: true, firstRun: true },
+    },
+  };
+
+  logger.info(
+    `[native-onboarding] Submitting first-run to ${apiBase}/api/first-run (runtime=${choice.runtime}, target=${runtimeTarget})`,
+  );
+
+  try {
+    const response = await fetch(`${apiBase}/api/first-run`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      logger.error(
+        `[native-onboarding] First-run API failed (${response.status}): ${text}`,
+      );
+      return false;
+    }
+
+    logger.info("[native-onboarding] First-run API succeeded");
+    return true;
+  } catch (err) {
+    logger.error(
+      `[native-onboarding] First-run API call failed: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return false;
+  }
+}
+
+/**
+ * Wait for the local API server to be ready by polling `/api/first-run/status`.
+ */
+export async function waitForApiReady(
+  apiBase: string,
+  timeoutMs = 60_000,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${apiBase}/api/first-run/status`);
+      if (res.ok) return true;
+    } catch {
+      // Server not ready yet
+    }
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+  return false;
+}