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

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

@@ -11,95 +11,103 @@ import { getGpuWindowManager } from "./gpu-window";
 import { getLocationManager } from "./location";
 import { getMusicPlayerManager } from "./music-player";
 import { getPermissionManager } from "./permissions";
+import { getRemotePluginHost } from "./remote-plugin-host";
 import { getScreenCaptureManager } from "./screencapture";
 import { isStewardLocalEnabled, stopSteward } from "./steward";
 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,
-	sendToWebview: SendToWebview,
+  mainWindow: BrowserWindow,
+  sendToWebview: SendToWebview,
 ): void {
-	const desktop = getDesktopManager();
-	desktop.setMainWindow(mainWindow);
-	desktop.setSendToWebview(sendToWebview);
+  const desktop = getDesktopManager();
+  desktop.setMainWindow(mainWindow);
+  desktop.setSendToWebview(sendToWebview);
 
-	getAgentManager().setSendToWebview(sendToWebview);
-	getBrowserWorkspaceManager().setSendToWebview(sendToWebview);
-	getCameraManager().setSendToWebview(sendToWebview);
-	getCanvasManager().setSendToWebview(sendToWebview);
-	getGatewayDiscovery().setSendToWebview(sendToWebview);
-	getGpuWindowManager().setSendToWebview(sendToWebview);
-	getLocationManager().setSendToWebview(sendToWebview);
-	getPermissionManager().setSendToWebview(sendToWebview);
-	const screencapture = getScreenCaptureManager();
-	screencapture.setSendToWebview(sendToWebview);
-	screencapture.setMainWebview(mainWindow.webview);
-	getSwabbleManager().setSendToWebview(sendToWebview);
-	getTalkModeManager().setSendToWebview(sendToWebview);
+  getAgentManager().setSendToWebview(sendToWebview);
+  getBrowserWorkspaceManager().setSendToWebview(sendToWebview);
+  getCameraManager().setSendToWebview(sendToWebview);
+  getCanvasManager().setSendToWebview(sendToWebview);
+  getGatewayDiscovery().setSendToWebview(sendToWebview);
+  getGpuWindowManager().setSendToWebview(sendToWebview);
+  getLocationManager().setSendToWebview(sendToWebview);
+  getPermissionManager().setSendToWebview(sendToWebview);
+  const screencapture = getScreenCaptureManager();
+  screencapture.setSendToWebview(sendToWebview);
+  screencapture.setMainWebview(mainWindow.webview);
+  getSwabbleManager().setSendToWebview(sendToWebview);
+  getTalkModeManager().setSendToWebview(sendToWebview);
 }
 
 export async function disposeNativeModules(): Promise<void> {
-	const managers = [
-		["agent", getAgentManager()],
-		["browser-workspace", getBrowserWorkspaceManager()],
-		["camera", getCameraManager()],
-		["canvas", getCanvasManager()],
-		["desktop", getDesktopManager()],
-		["gateway", getGatewayDiscovery()],
-		["gpu-window", getGpuWindowManager()],
-		["location", getLocationManager()],
-		["permissions", getPermissionManager()],
-		["screencapture", getScreenCaptureManager()],
-		["swabble", getSwabbleManager()],
-		["talkmode", getTalkModeManager()],
-		["music-player", getMusicPlayerManager()],
-	] as const;
+  nativeDisposePromise ??= disposeNativeModulesOnce();
+  return nativeDisposePromise;
+}
+
+async function disposeNativeModulesOnce(): Promise<void> {
+  const managers = [
+    ["agent", getAgentManager()],
+    ["browser-workspace", getBrowserWorkspaceManager()],
+    ["camera", getCameraManager()],
+    ["canvas", getCanvasManager()],
+    ["remote-plugins", getRemotePluginHost()],
+    ["desktop", getDesktopManager()],
+    ["gateway", getGatewayDiscovery()],
+    ["gpu-window", getGpuWindowManager()],
+    ["location", getLocationManager()],
+    ["permissions", getPermissionManager()],
+    ["screencapture", getScreenCaptureManager()],
+    ["swabble", getSwabbleManager()],
+    ["talkmode", getTalkModeManager()],
+    ["music-player", getMusicPlayerManager()],
+  ] as const;
 
-	// Stop steward sidecar if it was running
-	if (isStewardLocalEnabled()) {
-		try {
-			await stopSteward();
-		} catch (err) {
-			logger.warn(
-				`[Native] steward dispose failed: ${err instanceof Error ? err.message : String(err)}`,
-			);
-		}
-	}
+  // Stop steward sidecar if it was running
+  if (isStewardLocalEnabled()) {
+    try {
+      await stopSteward();
+    } catch (err) {
+      logger.warn(
+        `[Native] steward dispose failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
 
-	const settleDisposals = Promise.allSettled(
-		managers.map(async ([name, manager]) => {
-			try {
-				await Promise.resolve(manager.dispose());
-			} catch (err) {
-				logger.warn(
-					`[Native] ${name} dispose failed: ${err instanceof Error ? err.message : String(err)}`,
-				);
-			}
-		}),
-	);
+  const settleDisposals = Promise.allSettled(
+    managers.map(async ([name, manager]) => {
+      try {
+        await Promise.resolve(manager.dispose());
+      } catch (err) {
+        logger.warn(
+          `[Native] ${name} dispose failed: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }),
+  );
 
-	let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
-	const timedOut = await Promise.race([
-		settleDisposals.then(() => false),
-		new Promise<boolean>((resolve) => {
-			timeoutHandle = setTimeout(
-				() => resolve(true),
-				NATIVE_DISPOSE_TIMEOUT_MS,
-			);
-		}),
-	]);
-	if (timeoutHandle) {
-		clearTimeout(timeoutHandle);
-	}
+  let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  const timedOut = await Promise.race([
+    settleDisposals.then(() => false),
+    new Promise<boolean>((resolve) => {
+      timeoutHandle = setTimeout(
+        () => resolve(true),
+        NATIVE_DISPOSE_TIMEOUT_MS,
+      );
+    }),
+  ]);
+  if (timeoutHandle) {
+    clearTimeout(timeoutHandle);
+  }
 
-	if (timedOut) {
-		logger.warn(
-			`[Native] Timed out waiting ${NATIVE_DISPOSE_TIMEOUT_MS}ms for native module disposal`,
-		);
-	} else {
-		await settleDisposals;
-	}
+  if (timedOut) {
+    logger.warn(
+      `[Native] Timed out waiting ${NATIVE_DISPOSE_TIMEOUT_MS}ms for native module disposal`,
+    );
+  } else {
+    await settleDisposals;
+  }
 }

package/platforms/electrobun/src/native/location.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { logger } from "../logger";
+import { LocationManager } from "./location";
+
+vi.mock("../logger", () => ({
+  logger: {
+    debug: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+const originalFetch = globalThis.fetch;
+
+describe("LocationManager", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("logs failed IP geolocation providers before returning no position", async () => {
+    globalThis.fetch = vi.fn(async () => {
+      throw new Error("network down");
+    }) as unknown as typeof fetch;
+
+    await expect(
+      new LocationManager().getCurrentPosition(),
+    ).resolves.toBeNull();
+
+    expect(logger.warn).toHaveBeenCalledTimes(2);
+    expect(logger.warn).toHaveBeenCalledWith(
+      "[Location] IP geolocation provider failed",
+      expect.objectContaining({
+        error: "network down",
+        url: expect.any(String),
+      }),
+    );
+  });
+});

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

@@ -1,15 +1,16 @@
+import { logger } from "../logger";
 import type { SendToWebview } from "../types.js";
 
 interface GeoPosition {
-	latitude: number;
-	longitude: number;
-	accuracy: number;
-	timestamp: number;
+  latitude: number;
+  longitude: number;
+  accuracy: number;
+  timestamp: number;
 }
 
 const IP_GEO_SERVICES = [
-	"http://ip-api.com/json/?fields=lat,lon,status",
-	"https://ipapi.co/json/",
+  "http://ip-api.com/json/?fields=lat,lon,status",
+  "https://ipapi.co/json/",
 ];
 
 /**
@@ -27,84 +28,93 @@ const IP_GEO_SERVICES = [
  */
 const IP_GEO_ACCURACY_METERS = 5000;
 
+function locationErrorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
 export class LocationManager {
-	private sendToWebview: SendToWebview | null = null;
-	private lastKnown: GeoPosition | null = null;
-	private watchIntervals: Map<string, ReturnType<typeof setInterval>> =
-		new Map();
-	private watchCounter = 0;
-
-	setSendToWebview(fn: SendToWebview): void {
-		this.sendToWebview = fn;
-	}
-
-	async getCurrentPosition(): Promise<GeoPosition | null> {
-		for (const url of IP_GEO_SERVICES) {
-			try {
-				const resp = await fetch(url, { signal: AbortSignal.timeout(5000) });
-				if (!resp.ok) continue;
-				const data = await resp.json();
-
-				const lat = data.lat ?? data.latitude;
-				const lon = data.lon ?? data.longitude;
-				if (typeof lat !== "number" || typeof lon !== "number") continue;
-
-				const position: GeoPosition = {
-					latitude: lat,
-					longitude: lon,
-					accuracy: IP_GEO_ACCURACY_METERS,
-					timestamp: Date.now(),
-				};
-				this.lastKnown = position;
-				return position;
-			} catch {}
-		}
-		return null;
-	}
-
-	async watchPosition(options?: {
-		interval?: number;
-	}): Promise<{ watchId: string }> {
-		const watchId = `watch_${++this.watchCounter}`;
-		const interval = options?.interval ?? 60000; // 1 minute default
-
-		const timer = setInterval(async () => {
-			const pos = await this.getCurrentPosition();
-			if (pos) {
-				this.sendToWebview?.("locationUpdate", pos);
-			}
-		}, interval);
-
-		this.watchIntervals.set(watchId, timer);
-		return { watchId };
-	}
-
-	async clearWatch(options: { watchId: string }): Promise<void> {
-		const timer = this.watchIntervals.get(options.watchId);
-		if (timer) {
-			clearInterval(timer);
-			this.watchIntervals.delete(options.watchId);
-		}
-	}
-
-	async getLastKnownLocation(): Promise<GeoPosition | null> {
-		return this.lastKnown;
-	}
-
-	dispose(): void {
-		for (const timer of this.watchIntervals.values()) {
-			clearInterval(timer);
-		}
-		this.watchIntervals.clear();
-		this.sendToWebview = null;
-	}
+  private sendToWebview: SendToWebview | null = null;
+  private lastKnown: GeoPosition | null = null;
+  private watchIntervals: Map<string, ReturnType<typeof setInterval>> =
+    new Map();
+  private watchCounter = 0;
+
+  setSendToWebview(fn: SendToWebview): void {
+    this.sendToWebview = fn;
+  }
+
+  async getCurrentPosition(): Promise<GeoPosition | null> {
+    for (const url of IP_GEO_SERVICES) {
+      try {
+        const resp = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        if (!resp.ok) continue;
+        const data = await resp.json();
+
+        const lat = data.lat ?? data.latitude;
+        const lon = data.lon ?? data.longitude;
+        if (typeof lat !== "number" || typeof lon !== "number") continue;
+
+        const position: GeoPosition = {
+          latitude: lat,
+          longitude: lon,
+          accuracy: IP_GEO_ACCURACY_METERS,
+          timestamp: Date.now(),
+        };
+        this.lastKnown = position;
+        return position;
+      } catch (err) {
+        logger.warn("[Location] IP geolocation provider failed", {
+          url,
+          error: locationErrorMessage(err),
+        });
+      }
+    }
+    return null;
+  }
+
+  async watchPosition(options?: {
+    interval?: number;
+  }): Promise<{ watchId: string }> {
+    const watchId = `watch_${++this.watchCounter}`;
+    const interval = options?.interval ?? 60000; // 1 minute default
+
+    const timer = setInterval(async () => {
+      const pos = await this.getCurrentPosition();
+      if (pos) {
+        this.sendToWebview?.("locationUpdate", pos);
+      }
+    }, interval);
+
+    this.watchIntervals.set(watchId, timer);
+    return { watchId };
+  }
+
+  async clearWatch(options: { watchId: string }): Promise<void> {
+    const timer = this.watchIntervals.get(options.watchId);
+    if (timer) {
+      clearInterval(timer);
+      this.watchIntervals.delete(options.watchId);
+    }
+  }
+
+  async getLastKnownLocation(): Promise<GeoPosition | null> {
+    return this.lastKnown;
+  }
+
+  dispose(): void {
+    for (const timer of this.watchIntervals.values()) {
+      clearInterval(timer);
+    }
+    this.watchIntervals.clear();
+    this.sendToWebview = null;
+  }
 }
 
 let locationManager: LocationManager | null = null;
 
 export function getLocationManager(): LocationManager {
-	if (!locationManager) {
-		locationManager = new LocationManager();
-	}
-	return locationManager;
+  if (!locationManager) {
+    locationManager = new LocationManager();
+  }
+  return locationManager;
 }

package/platforms/electrobun/src/native/loopback-port.ts

@@ -4,54 +4,54 @@ const LISTEN_TIMEOUT_MS = 3000;
 const CLOSE_GRACE_MS = 250;
 
 function tryBindOnce(
-	port: number,
-	host: string,
+  port: number,
+  host: string,
 ): Promise<{ ok: true } | { ok: false }> {
-	return new Promise((resolve) => {
-		const server = createServer();
-		let settled = false;
+  return new Promise((resolve) => {
+    const server = createServer();
+    let settled = false;
 
-		const finish = (result: { ok: true } | { ok: false }) => {
-			if (settled) return;
-			settled = true;
-			server.removeAllListeners();
-			resolve(result);
-		};
+    const finish = (result: { ok: true } | { ok: false }) => {
+      if (settled) return;
+      settled = true;
+      server.removeAllListeners();
+      resolve(result);
+    };
 
-		const listenTimer = setTimeout(() => {
-			try {
-				server.close();
-			} catch {
-				/* already closed */
-			}
-			finish({ ok: false });
-		}, LISTEN_TIMEOUT_MS);
+    const listenTimer = setTimeout(() => {
+      try {
+        server.close();
+      } catch {
+        /* already closed */
+      }
+      finish({ ok: false });
+    }, LISTEN_TIMEOUT_MS);
 
-		const fail = () => {
-			clearTimeout(listenTimer);
-			finish({ ok: false });
-		};
+    const fail = () => {
+      clearTimeout(listenTimer);
+      finish({ ok: false });
+    };
 
-		server.once("error", fail);
-		server.listen({ port, host }, () => {
-			clearTimeout(listenTimer);
-			server.unref?.();
+    server.once("error", fail);
+    server.listen({ port, host }, () => {
+      clearTimeout(listenTimer);
+      server.unref();
 
-			// Bun on packaged Windows can occasionally never invoke the close
-			// callback even though the listen succeeded. Without this grace timer
-			// startup stalls before `port_selected`.
-			const closeTimer = setTimeout(() => finish({ ok: true }), CLOSE_GRACE_MS);
-			try {
-				server.close(() => {
-					clearTimeout(closeTimer);
-					finish({ ok: true });
-				});
-			} catch {
-				clearTimeout(closeTimer);
-				finish({ ok: true });
-			}
-		});
-	});
+      // Bun on packaged Windows can occasionally never invoke the close
+      // callback even though the listen succeeded. Without this grace timer
+      // startup stalls before `port_selected`.
+      const closeTimer = setTimeout(() => finish({ ok: true }), CLOSE_GRACE_MS);
+      try {
+        server.close(() => {
+          clearTimeout(closeTimer);
+          finish({ ok: true });
+        });
+      } catch {
+        clearTimeout(closeTimer);
+        finish({ ok: true });
+      }
+    });
+  });
 }
 
 /**
@@ -59,23 +59,23 @@ function tryBindOnce(
  * on `host`, or throws if none found within `maxHops` attempts.
  */
 export async function findFirstAvailableLoopbackPort(
-	preferred: number,
-	options?: { host?: string; maxHops?: number },
+  preferred: number,
+  options?: { host?: string; maxHops?: number },
 ): Promise<number> {
-	const host = options?.host ?? "127.0.0.1";
-	const maxHops = options?.maxHops ?? 64;
-	if (!Number.isFinite(preferred) || preferred < 1 || preferred > 65535) {
-		throw new Error(`Invalid preferred port: ${preferred}`);
-	}
-	for (let i = 0; i < maxHops; i++) {
-		const port = preferred + i;
-		if (port > 65535) break;
-		const result = await tryBindOnce(port, host);
-		if (result.ok) {
-			return port;
-		}
-	}
-	throw new Error(
-		`No free TCP port on ${host} in range ${preferred}–${preferred + maxHops - 1}`,
-	);
+  const host = options?.host ?? "127.0.0.1";
+  const maxHops = options?.maxHops ?? 64;
+  if (!Number.isFinite(preferred) || preferred < 1 || preferred > 65535) {
+    throw new Error(`Invalid preferred port: ${preferred}`);
+  }
+  for (let i = 0; i < maxHops; i++) {
+    const port = preferred + i;
+    if (port > 65535) break;
+    const result = await tryBindOnce(port, host);
+    if (result.ok) {
+      return port;
+    }
+  }
+  throw new Error(
+    `No free TCP port on ${host} in range ${preferred}–${preferred + maxHops - 1}`,
+  );
 }