@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

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

@@ -0,0 +1,119 @@
+/**
+ * api-base-owner — single source of truth for the renderer's API base URL.
+ *
+ * The renderer ("the WebView") needs a stable answer to "what loopback
+ * port is the agent API listening on?". Five sites used to push this
+ * answer independently:
+ *   1. HTML inject before any renderer JS runs (static-server path)
+ *   2. RPC push from `handleHomeWindowAgentReady`
+ *   3. RPC push from a runtime-mode change handler
+ *   4. RPC push from desktop-session priming
+ *   5. RPC push from the menu-action runtime restart handler
+ *
+ * Each site decided independently when to push and what value to push.
+ * The five copies were the disease behind the port-shift renderer
+ * disconnect MASTER.md §0 documents: a tactical fix in `RuntimeGate.tsx`
+ * patched the symptom, but until *one* module owns the value the
+ * renderer is reading, every new push site is a fresh chance to ship
+ * the wrong port.
+ *
+ * This module owns:
+ *   - the *current* API base + token (module singleton)
+ *   - the HTML inject snippet for the static server
+ *   - the per-window push (delegates to the existing
+ *     `pushApiBaseToRenderer` RPC plumbing in `../api-base.ts`)
+ *
+ * Callers say `setCurrent(base, token)` to update, then either inject
+ * via `injectIntoHtml(html)` (production static server) or push via
+ * `pushToWindow(win)` (any time after a window mounts). The HTML inject
+ * AND the RPC push read the same singleton, so the renderer can never
+ * see two sources of truth.
+ */
+
+import { pushApiBaseToRenderer } from "../api-base";
+
+interface ApiBaseSnapshot {
+	base: string | null;
+	token: string;
+}
+
+let current: ApiBaseSnapshot = { base: null, token: "" };
+
+function safeJsonForHtml(value: unknown): string {
+	return JSON.stringify(value).replace(/<\//g, "<\\/");
+}
+
+/**
+ * Update the singleton with the latest known API base + token. Subsequent
+ * `injectIntoHtml(...)` and `pushToWindow(...)` calls read this state.
+ *
+ * Call this at every point where the desktop main process learns the
+ * API has bound a port — after `resolveInitialApiBase`, after the
+ * agent supervisor confirms ready, after a runtime-mode change, etc.
+ */
+export function setCurrent(base: string | null, token: string = ""): void {
+	current = { base, token };
+}
+
+/** Read the current snapshot — for tests + diagnostic logging. */
+export function getCurrent(): Readonly<ApiBaseSnapshot> {
+	return current;
+}
+
+/**
+ * Inject the current API base + token into HTML before the first
+ * renderer JS runs. Returns the HTML unchanged if no base is set yet.
+ *
+ * Sets THREE keys for compatibility:
+ *   - `window.__ELIZA_API_BASE__` (legacy global the appClient reads)
+ *   - `window.__ELIZA_API_TOKEN__` (token global)
+ *   - `window.__ELIZAOS_APP_BOOT_CONFIG__` / `__ELIZA_APP_BOOT_CONFIG__`
+ *     plus the `Symbol.for("elizaos.app.boot-config")` slot (typed
+ *     boot config that SettingsView reads)
+ *
+ * Without the boot-config keys, the same renderer loaded via a regular
+ * browser at the static-server's origin falls back to `pageOrigin` for
+ * 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};})();`;
+	const script = `<script>window.__ELIZA_API_BASE__=${baseLiteral};${tokenInject}${bootConfigInject}</script>`;
+	if (html.includes("</head>")) {
+		return html.replace("</head>", `${script}</head>`);
+	}
+	if (html.includes("<body")) {
+		return html.replace("<body", `${script}<body`);
+	}
+	return script + html;
+}
+
+/**
+ * Push the current snapshot to one window via the RPC bridge. No-op if
+ * no base has been set yet (the receiving renderer would not know what
+ * to do with `null`). For broadcasting to multiple windows, callers
+ * should iterate their window registry and call this per window.
+ */
+export function pushToWindow(win: { webview: { rpc?: unknown } }): void {
+	if (!current.base) return;
+	pushApiBaseToRenderer(win, current.base, current.token || undefined);
+}
+
+/**
+ * Convenience: setCurrent + pushToWindow in one call. Use at the four
+ * RPC push sites in `../index.ts` that previously called
+ * `pushApiBaseToRenderer(win, base, token)` directly.
+ */
+export function notifyChange(
+	win: { webview: { rpc?: unknown } },
+	base: string | null,
+	token: string = "",
+): void {
+	setCurrent(base, token);
+	pushToWindow(win);
+}

package/platforms/electrobun/src/lifecycle/desktop-session-prime.ts

@@ -0,0 +1,77 @@
+import { Session } from "electrobun/bun";
+import { logger } from "../logger";
+import { resolveMainWindowPartition } from "../main-window-session";
+import {
+	type DesktopSession,
+	installDesktopSessionCookies,
+	loadOrCreateDesktopSession,
+} from "../native/auth-bridge";
+
+// Tracks whether the desktop loopback session has already been primed for the
+// current process lifetime. The bridge is idempotent on disk, but cookie jar
+// writes are cheap and we don't need to repeat them on every status tick.
+let desktopSessionPrimed = false;
+
+/**
+ * Reset the primed flag so the next call to primeDesktopSessionAuth() re-runs
+ * the bridge. Used when the embedded agent rebinds to a new loopback port —
+ * cookies installed for the old origin don't authenticate the new one.
+ */
+export function markDesktopSessionStale(): void {
+	desktopSessionPrimed = false;
+}
+
+/**
+ * Best-effort: mint (or reuse) a loopback-only desktop session and install the
+ * cookies into the main window's session jar so the renderer's first /api
+ * request is already authenticated. Failure is silent — the renderer falls
+ * back to the standard login flow.
+ *
+ * Loopback-only enforcement is implemented server-side: the auth-context
+ * resolver MUST refuse a session marked loopback-only on a non-loopback
+ * request. The bridge does not — and cannot — be that boundary.
+ */
+export async function primeDesktopSessionAuth(
+	apiBase: string,
+	rendererOrigin: string,
+): Promise<void> {
+	if (desktopSessionPrimed) return;
+	let session: DesktopSession | null;
+	try {
+		session = await loadOrCreateDesktopSession({ apiBase });
+	} catch (err) {
+		logger.warn(
+			`[Main] Desktop auth bridge failed: ${err instanceof Error ? err.message : String(err)}`,
+		);
+		return;
+	}
+	if (!session) {
+		logger.info(
+			"[Main] Desktop auth bridge produced no session; renderer will use the standard login flow.",
+		);
+		return;
+	}
+
+	try {
+		const partition = resolveMainWindowPartition(process.env);
+		const electrobunSession =
+			partition !== null
+				? Session.fromPartition(partition)
+				: Session.defaultSession;
+		const installer = electrobunSession.cookies as {
+			set: Parameters<typeof installDesktopSessionCookies>[0]["set"];
+		};
+		const touched = installDesktopSessionCookies(installer, session, {
+			apiOrigin: apiBase,
+			rendererOrigin,
+		});
+		desktopSessionPrimed = true;
+		logger.info(
+			`[Main] Desktop loopback session primed on ${touched.join(", ") || "<no targets>"}`,
+		);
+	} catch (err) {
+		logger.warn(
+			`[Main] Desktop auth cookie install failed: ${err instanceof Error ? err.message : String(err)}`,
+		);
+	}
+}

package/platforms/electrobun/src/logger.ts

@@ -0,0 +1,23 @@
+type LogMethod = (...args: unknown[]) => void;
+
+function bindConsoleMethod(
+	method: "debug" | "error" | "info" | "log" | "warn",
+): LogMethod {
+	return (...args: unknown[]) => {
+		console[method](...args);
+	};
+}
+
+export const logger: {
+	debug: LogMethod;
+	error: LogMethod;
+	info: LogMethod;
+	success: LogMethod;
+	warn: LogMethod;
+} = {
+	debug: bindConsoleMethod("debug"),
+	error: bindConsoleMethod("error"),
+	info: bindConsoleMethod("log"),
+	success: bindConsoleMethod("log"),
+	warn: bindConsoleMethod("warn"),
+};

package/platforms/electrobun/src/main-window-runtime.ts

@@ -0,0 +1,117 @@
+import type { BrowserWindow } from "electrobun/bun";
+import type { WebviewEvalRpc } from "./types.js";
+
+type TitleBarStyle = "hidden" | "hiddenInset" | "default";
+
+export interface MainWindowRuntimeSnapshot {
+	present: boolean;
+	windowId: number | null;
+	webviewId: number | null;
+	url: string | null;
+	titleBarStyle: TitleBarStyle | null;
+	transparent: boolean | null;
+	vibrancyEnabled: boolean | null;
+	shadowEnabled: boolean | null;
+	bounds: {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	} | null;
+}
+
+let currentWindow: BrowserWindow | null = null;
+let currentWindowMeta: Omit<
+	MainWindowRuntimeSnapshot,
+	"present" | "windowId" | "webviewId" | "url" | "bounds"
+> = {
+	titleBarStyle: null,
+	transparent: null,
+	vibrancyEnabled: null,
+	shadowEnabled: null,
+};
+
+export function setCurrentMainWindow(
+	window: BrowserWindow,
+	meta: {
+		titleBarStyle: TitleBarStyle;
+		transparent: boolean;
+	},
+): void {
+	currentWindow = window;
+	currentWindowMeta = {
+		...currentWindowMeta,
+		titleBarStyle: meta.titleBarStyle,
+		transparent: meta.transparent,
+	};
+}
+
+export function clearCurrentMainWindow(window?: BrowserWindow | null): void {
+	if (window && currentWindow && currentWindow.id !== window.id) {
+		return;
+	}
+	currentWindow = null;
+}
+
+export function updateCurrentMainWindowEffectsState(state: {
+	vibrancyEnabled?: boolean | null;
+	shadowEnabled?: boolean | null;
+}): void {
+	currentWindowMeta = {
+		...currentWindowMeta,
+		...(typeof state.vibrancyEnabled !== "undefined"
+			? { vibrancyEnabled: state.vibrancyEnabled }
+			: {}),
+		...(typeof state.shadowEnabled !== "undefined"
+			? { shadowEnabled: state.shadowEnabled }
+			: {}),
+	};
+}
+
+export function getCurrentMainWindowSnapshot(): MainWindowRuntimeSnapshot {
+	if (!currentWindow) {
+		return {
+			present: false,
+			windowId: null,
+			webviewId: null,
+			url: null,
+			bounds: null,
+			...currentWindowMeta,
+		};
+	}
+
+	const position = currentWindow.getPosition();
+	const size = currentWindow.getSize();
+
+	return {
+		present: true,
+		windowId: currentWindow.id ?? null,
+		webviewId: currentWindow.webviewId ?? null,
+		url:
+			(currentWindow.webview as { url?: string | null } | undefined)?.url ??
+			null,
+		bounds: {
+			x: position.x ?? 0,
+			y: position.y ?? 0,
+			width: size.width,
+			height: size.height,
+		},
+		...currentWindowMeta,
+	};
+}
+
+export async function evaluateInCurrentMainWindow(
+	script: string,
+): Promise<unknown> {
+	if (!currentWindow) {
+		throw new Error("main window is not available");
+	}
+
+	const rpc = currentWindow.webview.rpc as WebviewEvalRpc | undefined;
+	const evaluator = rpc?.requestProxy?.evaluateJavascriptWithResponse;
+	if (!evaluator) {
+		throw new Error("main window webview does not support JS evaluation");
+	}
+
+	return await evaluator({ script });
+}

package/platforms/electrobun/src/main-window-session.ts

@@ -0,0 +1,88 @@
+import { getBrandConfig } from "./brand-config";
+
+export const PACKAGED_WINDOWS_BOOTSTRAP_PARTITION =
+	"persist:bootstrap-isolated";
+export const MAC_DESKTOP_CEF_PARTITION = getBrandConfig().cefDesktopPartition;
+
+type Renderer = "native" | "cef";
+
+type BuildInfo = {
+	defaultRenderer: Renderer;
+	availableRenderers: Renderer[];
+};
+
+function trimToNull(value: string | undefined): string | null {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : null;
+}
+
+function normalizePersistentPartition(partition: string): string {
+	return partition.includes(":") ? partition : `persist:${partition}`;
+}
+
+function parseEnabledFlag(value: string | null): boolean {
+	if (!value) {
+		return false;
+	}
+
+	switch (value.toLowerCase()) {
+		case "0":
+		case "false":
+		case "no":
+		case "off":
+			return false;
+		default:
+			return true;
+	}
+}
+
+export function shouldForceMainWindowCef(
+	env: NodeJS.ProcessEnv = process.env,
+): boolean {
+	if (process.platform !== "darwin") {
+		return false;
+	}
+
+	return parseEnabledFlag(trimToNull(env.ELIZA_DESKTOP_FORCE_CEF));
+}
+
+export function shouldUseHeadlessDesktopSmoke(
+	env: NodeJS.ProcessEnv = process.env,
+): boolean {
+	return parseEnabledFlag(trimToNull(env.ELIZA_DESKTOP_HEADLESS_SMOKE));
+}
+
+export function resolveMainWindowPartition(
+	env: NodeJS.ProcessEnv = process.env,
+): string | null {
+	const explicit = trimToNull(env.ELIZA_DESKTOP_TEST_PARTITION);
+	if (explicit) {
+		return normalizePersistentPartition(explicit);
+	}
+
+	if (trimToNull(env.ELIZA_DESKTOP_TEST_API_BASE)) {
+		// The Windows smoke harness redirects APPDATA/LOCALAPPDATA before launch,
+		// so the bootstrap renderer can now use a persistent isolated partition.
+		return PACKAGED_WINDOWS_BOOTSTRAP_PARTITION;
+	}
+
+	if (shouldForceMainWindowCef(env)) {
+		return MAC_DESKTOP_CEF_PARTITION;
+	}
+
+	return null;
+}
+
+export function resolveBootstrapShellRenderer(buildInfo: BuildInfo): Renderer {
+	if (buildInfo.availableRenderers.includes("native")) {
+		return "native";
+	}
+	return buildInfo.defaultRenderer;
+}
+
+export function resolveBootstrapViewRenderer(buildInfo: BuildInfo): Renderer {
+	if (buildInfo.availableRenderers.includes("cef")) {
+		return "cef";
+	}
+	return buildInfo.defaultRenderer;
+}

package/platforms/electrobun/src/menu-reset-from-main.ts

@@ -0,0 +1,211 @@
+import { getBrandConfig } from "./brand-config";
+
+/**
+ * Main-process "Reset the app" menu flow — **testable** fetch/restart/poll core.
+ *
+ * **WHY extract from `index.ts`:** menu reset is security- and UX-sensitive; unit
+ * tests need mocked `fetch` without booting Electrobun. **WHY `pickReachable*`
+ * uses `res.ok`:** 4xx/5xx must not count as a valid API base for
+ * `POST /api/agent/reset`. **WHY embedded port first in candidates:** external
+ * `ELIZA_DESKTOP_API_BASE` often points at a dev server that is down while the
+ * embedded agent still listens on a dynamic loopback port.
+ *
+ * Native confirm, `Utils.showNotification`, and `getAgentManager()` stay in
+ * `index.ts` (`resetthe appFromApplicationMenu`).
+ */
+
+export type FetchLike = (
+	input: string,
+	init?: RequestInit,
+) => Promise<Response>;
+
+export const MAIN_RESET_API_PROBE_TIMEOUT_MS = 4000;
+export const MENU_RESET_STATUS_POLL_MS = 1000;
+export const MENU_RESET_STATUS_MAX_MS = 120_000;
+export const MENU_RESET_VERIFY_RETRIES = 1;
+
+export function buildMainMenuResetApiCandidates(options: {
+	embeddedPort: number | null | undefined;
+	configuredBase: string | null;
+}): string[] {
+	const candidates: string[] = [];
+	if (typeof options.embeddedPort === "number" && options.embeddedPort > 0) {
+		candidates.push(`http://127.0.0.1:${options.embeddedPort}`);
+	}
+	const configured = options.configuredBase;
+	if (configured && !candidates.includes(configured)) {
+		candidates.push(configured);
+	}
+	return candidates;
+}
+
+export async function pickReachableMenuResetApiBase(options: {
+	candidates: string[];
+	fetchImpl: FetchLike;
+	buildHeaders: () => Record<string, string>;
+	probeTimeoutMs?: number;
+}): Promise<string | null> {
+	if (options.candidates.length === 0) {
+		return null;
+	}
+	const timeoutMs = options.probeTimeoutMs ?? MAIN_RESET_API_PROBE_TIMEOUT_MS;
+	for (const base of options.candidates) {
+		try {
+			const res = await options.fetchImpl(`${base}/api/status`, {
+				method: "GET",
+				headers: options.buildHeaders(),
+				signal: AbortSignal.timeout(timeoutMs),
+			});
+			if (res.ok) {
+				return base;
+			}
+		} catch {
+			/* try next candidate */
+		}
+	}
+	return null;
+}
+
+export async function pollMenuResetAgentStatusJson(options: {
+	apiBase: string;
+	fetchImpl: FetchLike;
+	buildHeaders: () => Record<string, string>;
+	pollMs?: number;
+	maxMs?: number;
+	sleep?: (ms: number) => Promise<void>;
+	now?: () => number;
+}): Promise<Record<string, unknown>> {
+	const pollMs = options.pollMs ?? MENU_RESET_STATUS_POLL_MS;
+	const maxMs = options.maxMs ?? MENU_RESET_STATUS_MAX_MS;
+	const sleep =
+		options.sleep ?? ((ms: number) => new Promise((r) => setTimeout(r, ms)));
+	const now = options.now ?? (() => Date.now());
+	const deadline = now() + maxMs;
+	while (now() < deadline) {
+		try {
+			const res = await options.fetchImpl(`${options.apiBase}/api/status`, {
+				headers: options.buildHeaders(),
+			});
+			if (res.ok) {
+				const data = (await res.json()) as Record<string, unknown>;
+				if (data.state === "running") {
+					return data;
+				}
+			}
+		} catch {
+			/* agent may still be binding */
+		}
+		await sleep(pollMs);
+	}
+	try {
+		const res = await options.fetchImpl(`${options.apiBase}/api/status`, {
+			headers: options.buildHeaders(),
+		});
+		if (res.ok) {
+			return (await res.json()) as Record<string, unknown>;
+		}
+	} catch {
+		/* fall through */
+	}
+	return { state: "error", agentName: getBrandConfig().appName };
+}
+
+export type MainMenuResetPostConfirmDeps = {
+	apiBase: string;
+	fetchImpl: FetchLike;
+	buildHeaders: () => Record<string, string>;
+	/** `true` when `resolveDesktopRuntimeMode(env).mode === "local"`. */
+	useEmbeddedRestart: boolean;
+	restartEmbeddedClearingLocalDb: () => Promise<{ port?: number }>;
+	/** Called when embedded restart returns a port (local mode). */
+	pushEmbeddedApiBaseToRenderer: (
+		port: number | undefined,
+		apiToken: string,
+	) => void;
+	getLocalApiAuthToken: () => string;
+	/** External / non-embedded: POST restart (errors ignored). */
+	postExternalAgentRestart: () => Promise<void>;
+	resolveApiBaseForStatusPoll: () => string;
+	sendMenuResetAppliedToRenderer: (payload: {
+		itemId: "menu-reset-app-applied";
+		agentStatus: Record<string, unknown>;
+	}) => void;
+};
+
+/**
+ * After the user confirms reset and a reachable `apiBase` is known: POST reset,
+ * restart (embedded or HTTP), poll status, notify renderer.
+ */
+export async function runMainMenuResetAfterApiBaseResolved(
+	d: MainMenuResetPostConfirmDeps,
+): Promise<void> {
+	const executeResetAndRestart = async (): Promise<Record<string, unknown>> => {
+		const resetRes = await d.fetchImpl(`${d.apiBase}/api/agent/reset`, {
+			method: "POST",
+			headers: d.buildHeaders(),
+		});
+		if (!resetRes.ok) {
+			throw new Error(`Reset API failed (${resetRes.status})`);
+		}
+
+		if (d.useEmbeddedRestart) {
+			const status = await d.restartEmbeddedClearingLocalDb();
+			const apiToken = d.getLocalApiAuthToken();
+			if (status.port) {
+				d.pushEmbeddedApiBaseToRenderer(status.port, apiToken);
+			}
+		} else {
+			await d.postExternalAgentRestart();
+			// Push current API base + token to renderer after external restart
+			// so the client reconnects with valid auth credentials.
+			const apiToken = d.getLocalApiAuthToken();
+			d.pushEmbeddedApiBaseToRenderer(undefined, apiToken);
+		}
+
+		const pollBase = d.resolveApiBaseForStatusPoll();
+		return pollMenuResetAgentStatusJson({
+			apiBase: pollBase,
+			fetchImpl: d.fetchImpl,
+			buildHeaders: d.buildHeaders,
+		});
+	};
+
+	const readOnboardingComplete = async (): Promise<boolean | null> => {
+		try {
+			const res = await d.fetchImpl(`${d.apiBase}/api/onboarding/status`, {
+				method: "GET",
+				headers: d.buildHeaders(),
+			});
+			if (!res.ok) {
+				return null;
+			}
+			const payload = (await res.json()) as { complete?: unknown };
+			return typeof payload.complete === "boolean" ? payload.complete : null;
+		} catch {
+			return null;
+		}
+	};
+
+	let statusPayload = await executeResetAndRestart();
+	let onboardingComplete = await readOnboardingComplete();
+
+	for (
+		let attempt = 0;
+		onboardingComplete === true && attempt < MENU_RESET_VERIFY_RETRIES;
+		attempt += 1
+	) {
+		statusPayload = await executeResetAndRestart();
+		onboardingComplete = await readOnboardingComplete();
+	}
+
+	if (onboardingComplete === true) {
+		throw new Error(
+			"Reset verification failed: onboarding still marked complete",
+		);
+	}
+
+	d.sendMenuResetAppliedToRenderer({
+		itemId: "menu-reset-app-applied",
+		agentStatus: statusPayload,
+	});
+}