gloomberb 0.9.4 → 0.9.6

package/src/remote/server.ts

@@ -0,0 +1,121 @@
+import { randomUUID } from "crypto";
+import { createServer, type IncomingMessage, type ServerResponse } from "http";
+import type { RemoteAppKind, RemoteControlRequest, RemoteControlResponse, RemoteEndpoint } from "./types";
+import { REMOTE_CONTROL_PROTOCOL_VERSION } from "./types";
+import { removeRemoteEndpointFiles, writeRemoteEndpointFiles } from "./endpoint";
+
+export interface RemoteControlServerOptions {
+  dataDir: string;
+  appKind: RemoteAppKind;
+  handle: (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
+}
+
+export interface RemoteControlServer {
+  endpoint: RemoteEndpoint;
+  close(): Promise<void>;
+}
+
+const MAX_BODY_BYTES = 2 * 1024 * 1024;
+
+export async function startRemoteControlServer(options: RemoteControlServerOptions): Promise<RemoteControlServer> {
+  const token = randomUUID();
+  const httpServer = createServer((request, response) => {
+    void handleHttpRequest(options.handle, token, request, response);
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(0, "127.0.0.1", () => {
+      httpServer.off("error", reject);
+      resolve();
+    });
+  });
+
+  const address = httpServer.address();
+  if (!address || typeof address === "string") {
+    httpServer.close();
+    throw new Error("Remote control server did not bind to a TCP port.");
+  }
+
+  const endpoint: RemoteEndpoint = {
+    protocolVersion: REMOTE_CONTROL_PROTOCOL_VERSION,
+    appKind: options.appKind,
+    pid: process.pid,
+    port: address.port,
+    token,
+    startedAt: new Date().toISOString(),
+  };
+  await writeRemoteEndpointFiles(options.dataDir, endpoint);
+
+  return {
+    endpoint,
+    close: async () => {
+      await new Promise<void>((resolve, reject) => {
+        httpServer.close((error) => (error ? reject(error) : resolve()));
+      }).catch((error) => {
+        if ((error as NodeJS.ErrnoException).code !== "ERR_SERVER_NOT_RUNNING") throw error;
+      });
+      await removeRemoteEndpointFiles(options.dataDir, endpoint);
+    },
+  };
+}
+
+async function handleHttpRequest(
+  handle: RemoteControlServerOptions["handle"],
+  token: string,
+  request: IncomingMessage,
+  response: ServerResponse,
+): Promise<void> {
+  try {
+    if (request.method === "GET" && request.url === "/health") {
+      sendJson(response, 200, { ok: true });
+      return;
+    }
+    if (request.method !== "POST" || request.url !== "/rpc") {
+      sendJson(response, 404, { ok: false, error: { code: "not_found", message: "Unknown remote control endpoint." } });
+      return;
+    }
+    if (request.headers.authorization !== `Bearer ${token}`) {
+      sendJson(response, 401, { ok: false, error: { code: "unauthorized", message: "Invalid remote control token." } });
+      return;
+    }
+
+    const body = await readBody(request);
+    const remoteRequest = JSON.parse(body) as RemoteControlRequest;
+    sendJson(response, 200, await handle(remoteRequest));
+  } catch (error) {
+    sendJson(response, 500, {
+      ok: false,
+      error: {
+        code: "remote_transport_error",
+        message: error instanceof Error ? error.message : String(error),
+      },
+    });
+  }
+}
+
+async function readBody(request: IncomingMessage): Promise<string> {
+  let total = 0;
+  const chunks: Uint8Array[] = [];
+  for await (const chunk of request) {
+    const bytes = chunk instanceof Uint8Array ? new Uint8Array(chunk) : new TextEncoder().encode(String(chunk));
+    total += bytes.byteLength;
+    if (total > MAX_BODY_BYTES) throw new Error("Remote control request is too large.");
+    chunks.push(bytes);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(body);
+}
+
+function sendJson(response: ServerResponse, status: number, body: unknown): void {
+  response.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+  });
+  response.end(JSON.stringify(body));
+}

package/src/remote/types.ts

@@ -0,0 +1,119 @@
+export const REMOTE_CONTROL_PROTOCOL_VERSION = 1;
+
+export type RemoteAppKind = "tui" | "desktop";
+
+export interface RemoteEndpoint {
+  protocolVersion: number;
+  appKind: RemoteAppKind;
+  pid: number;
+  port: number;
+  token: string;
+  startedAt: string;
+}
+
+export interface RemoteJsonPatchOperation {
+  op: "add" | "replace" | "remove";
+  path: string;
+  value?: unknown;
+}
+
+export type RemoteStateInclude =
+  | "app"
+  | "layout"
+  | "panes"
+  | "commandBar"
+  | "commandBar.results"
+  | "ui"
+  | "schema"
+  | "help"
+  | "all";
+
+export type RemoteControlRequest =
+  | { type: "help"; topic?: string }
+  | { type: "schema" }
+  | { type: "get"; resource: string; include?: RemoteStateInclude[] }
+  | { type: "call"; operation: string; input?: unknown; dryRun?: boolean; include?: RemoteStateInclude[] }
+  | {
+    type: "patch";
+    resource: string;
+    patch: RemoteJsonPatchOperation[];
+    expectRev?: string;
+    dryRun?: boolean;
+    include?: RemoteStateInclude[];
+  }
+  | {
+    type: "batch";
+    requests: RemoteControlRequest[];
+    dryRun?: boolean;
+    haltOnError?: boolean;
+    settle?: "none" | "afterEach" | "afterBatch";
+    include?: RemoteStateInclude[];
+  };
+
+export interface RemoteIncludedState {
+  rev: string;
+  included: RemoteStateInclude[];
+  app?: unknown;
+  layout?: unknown;
+  panes?: unknown;
+  commandBar?: unknown;
+  ui?: RemoteUiNodeSnapshot[];
+  schema?: RemoteControlSchema;
+  help?: unknown;
+}
+
+export interface RemoteControlSuccess<T = unknown> {
+  ok: true;
+  data: T;
+  rev?: string;
+  state?: RemoteIncludedState;
+  warnings?: string[];
+}
+
+export interface RemoteControlFailure {
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+export type RemoteControlResponse<T = unknown> =
+  | RemoteControlSuccess<T>
+  | RemoteControlFailure;
+
+export interface RemoteResourceSchema {
+  uri: string;
+  description: string;
+  patchable?: boolean;
+}
+
+export interface RemoteOperationSchema {
+  id: string;
+  description: string;
+  inputShape?: string;
+  outputShape?: string;
+  returns?: string;
+  recommendedNextReads?: string[];
+  examples?: unknown[];
+  sideEffectLevel: "none" | "local-write" | "network-write" | "external-side-effect" | "external-trade";
+  requiresConfirmation?: boolean;
+  dryRun?: boolean;
+}
+
+export interface RemoteControlSchema {
+  protocolVersion: number;
+  resources: RemoteResourceSchema[];
+  operations: RemoteOperationSchema[];
+  help: unknown;
+}
+
+export interface RemoteUiNodeSnapshot {
+  id: string;
+  role: string;
+  label?: string;
+  disabled?: boolean;
+  actions: string[];
+  metadata?: Record<string, unknown>;
+}

package/src/renderers/electrobun/bun/index.ts

@@ -55,6 +55,8 @@ import {
   desktopWindowStyleMask,
 } from "./desktop/window-style";
 import { applyDesktopWindowControl, type DesktopWindowControlAction } from "./desktop/window-controls";
+import { startRemoteControlServer, type RemoteControlServer } from "../../../remote/server";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type DesktopRpc = ReturnType<typeof BrowserView.defineRPC<ElectrobunDesktopRpcSchema>>;
 
@@ -70,6 +72,7 @@ let services: AppServices | null = null;
 let mainWindow: BrowserWindow | null = null;
 let desktopWorkspace: DesktopWorkspace | null = null;
 let desktopRestartInProgress = false;
+let desktopRemoteControlServer: RemoteControlServer | null = null;
 
 const windowRpcRegistry = createDesktopRpcRegistry<DesktopRpc>();
 const contextMenuRequestRpcs = new Map<string, DesktopRpc>();
@@ -100,6 +103,10 @@ function requireDesktopWorkspace(): DesktopWorkspace {
   return desktopWorkspace;
 }
 
+function remoteFailure(code: string, message: string): RemoteControlResponse {
+  return { ok: false, error: { code, message } };
+}
+
 const {
   forEachReadyWindowRpc,
   getRpcWindowKey,
@@ -130,6 +137,46 @@ const detachedWindowManager = new DesktopDetachedWindowManager<DesktopRpc>({
   stateBroadcaster: desktopStateBroadcaster,
 });
 
+async function forwardRemoteControlRequest(request: RemoteControlRequest): Promise<RemoteControlResponse> {
+  const rpc = getWindowRpc(MAIN_WINDOW_RPC_KEY);
+  if (!rpc || !isWindowRpcReady(MAIN_WINDOW_RPC_KEY)) {
+    return remoteFailure("remote_unavailable", "The main desktop window is not ready for remote control requests.");
+  }
+  try {
+    const response = await rpc.request["remote.request"]({
+      request: encodeRpcValue(request) as RemoteControlRequest,
+    });
+    return decodeRpcValue<RemoteControlResponse>(response);
+  } catch (error) {
+    return remoteFailure(
+      "remote_forward_error",
+      error instanceof Error ? error.message : String(error),
+    );
+  }
+}
+
+async function ensureDesktopRemoteControlServer(): Promise<void> {
+  if (desktopRemoteControlServer) return;
+  const config = requireConfig();
+  desktopRemoteControlServer = await startRemoteControlServer({
+    dataDir: config.dataDir,
+    appKind: "desktop",
+    handle: forwardRemoteControlRequest,
+  });
+  console.error("[remote] desktop control endpoint started", {
+    port: desktopRemoteControlServer.endpoint.port,
+  });
+}
+
+function stopDesktopRemoteControlServer(): void {
+  const server = desktopRemoteControlServer;
+  desktopRemoteControlServer = null;
+  if (!server) return;
+  void server.close().catch((error) => {
+    console.error("[remote] desktop control endpoint cleanup failed", summarizeError(error));
+  });
+}
+
 function openMainWindowDevTools(): void {
   mainWindow?.webview.openDevTools();
 }
@@ -228,6 +275,7 @@ function disposeWindowScopedResources(windowKey: string): void {
 }
 
 function teardownServices(): void {
+  stopDesktopRemoteControlServer();
   capabilityBridge.disposeAll();
   services?.destroy();
   services = null;
@@ -306,7 +354,7 @@ async function initialize(
   rpc: DesktopRpc,
   payload: Record<string, unknown>,
 ) {
-  return initializeDesktopBackend({
+  const init = await initializeDesktopBackend({
     getCurrentConfig: () => currentConfig,
     getCurrentServices: () => services,
     getDesktopSnapshot,
@@ -328,6 +376,12 @@ async function initialize(
     },
     syncConfigAccessors,
   });
+  if (init.windowKind === "main") {
+    void ensureDesktopRemoteControlServer().catch((error) => {
+      console.error("[remote] desktop control endpoint failed", summarizeError(error));
+    });
+  }
+  return init;
 }
 
 async function handleBackendRequest(

package/src/renderers/electrobun/shared/protocol.ts

@@ -4,6 +4,7 @@ import type { DesktopApplicationMenuCommand } from "../../../types/desktop-menu"
 import type { AppConfig } from "../../../types/config";
 import type { UpdateProgress } from "../../../updater";
 import type { CapabilityManifest } from "../../../capabilities";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 export const ELECTROBUN_CONTEXT_MENU_ACTION = "gloom.context-menu.select";
 
@@ -59,6 +60,10 @@ export interface DesktopRestartMessage {
   source?: string;
 }
 
+export interface RemoteControlRequestMessage {
+  request: RemoteControlRequest;
+}
+
 export interface ElectrobunDesktopRpcSchema {
   bun: {
     requests: {
@@ -72,7 +77,12 @@ export interface ElectrobunDesktopRpcSchema {
     };
   };
   webview: {
-    requests: {};
+    requests: {
+      "remote.request": {
+        params: RemoteControlRequestMessage;
+        response: RemoteControlResponse;
+      };
+    };
     messages: {
       "context-menu.select": ContextMenuSelectMessage;
       "application-menu.select": ApplicationMenuSelectMessage;

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -9,10 +9,12 @@ import {
   type DesktopStateMessage,
   type DesktopThemePreviewMessage,
   type ElectrobunBackendInit,
+  type RemoteControlRequestMessage,
   type ElectrobunDesktopRpcSchema,
   type UpdateProgressMessage,
 } from "../shared/protocol";
 import { decodeRpcValue, encodeRpcValue } from "./rpc-codec";
+import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type ContextMenuSelectListener = (message: ContextMenuSelectMessage) => void;
 type ApplicationMenuSelectListener = (message: ApplicationMenuSelectMessage) => void;
@@ -21,8 +23,10 @@ type DesktopDockPreviewListener = (message: DesktopDockPreviewMessage) => void;
 type DesktopThemePreviewListener = (message: DesktopThemePreviewMessage) => void;
 type UpdateProgressListener = (message: UpdateProgressMessage) => void;
 type CapabilityEventListener = (message: CapabilityEventMessage) => void;
+type RemoteControlRequestHandler = (request: RemoteControlRequest) => Promise<RemoteControlResponse>;
 
 let initSnapshot: ElectrobunBackendInit | null = null;
+let remoteControlRequestHandler: RemoteControlRequestHandler | null = null;
 const contextMenuSelectListeners = new Map<string, Set<ContextMenuSelectListener>>();
 const applicationMenuSelectListeners = new Set<ApplicationMenuSelectListener>();
 const desktopStateListeners = new Set<DesktopStateListener>();
@@ -63,7 +67,21 @@ function subscribe<T>(
 const rpc = Electroview.defineRPC<ElectrobunDesktopRpcSchema>({
   maxRequestTime: 120_000,
   handlers: {
-    requests: {},
+    requests: {
+      "remote.request": async (message: RemoteControlRequestMessage) => {
+        if (!remoteControlRequestHandler) {
+          return {
+            ok: false,
+            error: {
+              code: "remote_unavailable",
+              message: "The desktop app has not installed a remote control handler yet.",
+            },
+          };
+        }
+        const decoded = decodeRpcValue<RemoteControlRequest>(message.request);
+        return encodeRpcValue(await remoteControlRequestHandler(decoded)) as RemoteControlResponse;
+      },
+    },
     messages: {
       "context-menu.select": (message) => {
         dispatch(contextMenuSelectListeners, message.requestId, message);
@@ -140,6 +158,15 @@ export function getElectrobunBackendInitSnapshot(): ElectrobunBackendInit | null
   return initSnapshot;
 }
 
+export function setElectrobunRemoteRequestHandler(handler: RemoteControlRequestHandler | null): () => void {
+  remoteControlRequestHandler = handler;
+  return () => {
+    if (remoteControlRequestHandler === handler) {
+      remoteControlRequestHandler = null;
+    }
+  };
+}
+
 export function onCapabilityEvent(
   subscriptionId: string,
   listener: (message: CapabilityEventMessage) => void,

package/src/renderers/electrobun/view/build-assets.ts

@@ -23,6 +23,7 @@ const COMMON_ALIAS_RULES: AliasRule[] = [
   ["./kitty/support", "components/chart/native/renderer-selection.ts", "native-stubs/chart/kitty-support.ts"],
   ["native/surface/manager", "native-stubs/chart/surface-manager.ts"],
   ["native/surface/sync", "native-stubs/chart/surface-sync.ts"],
+  ["./native-loader", "plugins/ibkr/gateway/service/index.ts", "native-stubs/ibkr-native-loader.ts"],
 ];
 
 export function electrobunViewPath(...parts: string[]): string {

package/src/renderers/electrobun/view/data-table/index.tsx

@@ -53,8 +53,6 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
   scrollRef,
   syncHeaderScroll: _syncHeaderScroll,
   onBodyScrollActivity,
-  hoveredIdx,
-  setHoveredIdx,
   getItemKey,
   isSelected,
   onSelect,
@@ -257,9 +255,6 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
           focusPane();
           onTableMouseDown?.({});
         }}
-        onMouseLeave={() => {
-          if (hoveredIdx !== null) setHoveredIdx(null);
-        }}
         onScroll={() => {
           markScrollbarActive();
           scheduleBodyScrollActivity();
@@ -315,7 +310,6 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
                 const item = items[row.index];
                 if (!item) return null;
                 const selected = isSelected(item, row.index);
-                const hovered = hoveredIdx === row.index && !selected;
                 const itemKey = getItemKey(item, row.index);
                 return (
                   <WebDataTableRow<T, C>
@@ -335,13 +329,11 @@ export function WebDataTable<T, C extends DataTableColumn = DataTableColumn>({
                     onRowContextMenu={onRowContextMenu}
                     onRowMouseDown={onRowMouseDown}
                     onSelectRow={selectRow}
-                    hovered={hovered}
                     getRowBackgroundColor={getRowBackgroundColor}
                     renderCell={renderCell}
                     renderSectionHeader={renderSectionHeader}
                     rowContextMenuSurface={rowContextMenuSurface}
                     selected={selected}
-                    setHoveredIdx={setHoveredIdx}
                   />
                 );
               }),

package/src/renderers/electrobun/view/data-table/row.tsx

@@ -12,7 +12,6 @@ import type {
 import { WEB_CELL_HEIGHT } from "../input-host";
 import {
   CSS_BG,
-  CSS_HOVER_BG,
   CSS_PANEL,
   CSS_SELECTED,
   CSS_SELECTED_TEXT,
@@ -151,7 +150,6 @@ function WebDataTableRowInner<
   onRowContextMenu,
   onRowMouseDown,
   onSelectRow,
-  hovered,
   index,
   item,
   itemKey,
@@ -163,7 +161,6 @@ function WebDataTableRowInner<
   rowStart,
   rowContextMenuSurface,
   selected,
-  setHoveredIdx,
 }: {
   columns: C[];
   columnGap: number;
@@ -174,7 +171,6 @@ function WebDataTableRowInner<
   onRowContextMenu?: DataTableProps<T, C>["onRowContextMenu"];
   onRowMouseDown?: DataTableProps<T, C>["onRowMouseDown"];
   onSelectRow: (item: T, index: number) => void;
-  hovered: boolean;
   index: number;
   item: T;
   itemKey: string;
@@ -186,7 +182,6 @@ function WebDataTableRowInner<
   rowStart: number;
   rowContextMenuSurface: boolean;
   selected: boolean;
-  setHoveredIdx: (index: number | null) => void;
 }) {
   useThemeColors();
   const sectionHeader: DataTableSectionHeader | null =
@@ -242,13 +237,11 @@ function WebDataTableRowInner<
     );
   }
 
-  const rowState = { selected, hovered };
+  const rowState = { selected };
   const rowBackgroundColor = getRowBackgroundColor?.(item, index, rowState);
   const rowBg = selected
     ? CSS_SELECTED
-    : hovered
-      ? CSS_HOVER_BG
-      : rowBackgroundColor ?? CSS_BG;
+    : rowBackgroundColor ?? CSS_BG;
 
   return (
     <div
@@ -260,9 +253,6 @@ function WebDataTableRowInner<
         ...baseRowStyle,
         backgroundColor: rowBg,
       }}
-      onMouseMove={() => {
-        if (!hovered) setHoveredIdx(index);
-      }}
       onMouseDown={(event) => {
         focusPane();
         onTableMouseDown?.(event);

package/src/renderers/electrobun/view/host/box.tsx

@@ -33,6 +33,9 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
     const pendingDragRef = useRef<CellMouseEvent | null>(null);
     const propsRef = useRef(props);
     propsRef.current = props;
+    const hoverBackgroundColor = typeof props.hoverBackgroundColor === "string"
+      ? props.hoverBackgroundColor
+      : undefined;
 
     useImperativeHandle(ref, () => cellBoundsForElement(() => elementRef.current, () => propsRef.current) as unknown as HTMLDivElement, []);
 
@@ -132,6 +135,10 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
       callMouseHandler(propsRef.current.onMouseScroll, event, "scroll");
     };
 
+    const handleMouseOver = (event: MouseEvent) => {
+      callMouseHandler(propsRef.current.onMouseOver, event, "over");
+    };
+
     const handleMouseOut = (event: MouseEvent) => {
       pendingMoveRef.current = null;
       callMouseHandler(propsRef.current.onMouseOut, event, "out");
@@ -140,18 +147,21 @@ export const WebBox = forwardRef<HTMLDivElement, Record<string, unknown> & { chi
     return (
       <div
         {...cleanDomProps(props)}
+        data-gloom-hover-bg={hoverBackgroundColor ? "true" : undefined}
         data-gloom-interactive={hasDirectMouseHandler(props) ? "true" : undefined}
         ref={elementRef}
         onMouseDown={handleMouseDown}
+        onMouseOver={handleMouseOver}
         onMouseMove={(event) => scheduleFrameMouseHandler(event, "move")}
         onMouseUp={(event) => callMouseHandler(propsRef.current.onMouseUp, event, "up")}
         onMouseOut={handleMouseOut}
         onWheel={typeof props.onMouseScroll === "function" ? handleWheel : undefined}
         style={{
           ...commonStyle(props),
+          "--gloom-box-hover-bg": hoverBackgroundColor,
           ...(props.style as CSSProperties | undefined),
           ...(props.visible === false ? { display: "none" } : undefined),
-        }}
+        } as CSSProperties}
       >
         {children as ReactNode}
       </div>

package/src/renderers/electrobun/view/host/mouse.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { hasDirectMouseHandler, mouseHandlers } from "./mouse";
+
+function fakeMouseEvent() {
+  return {
+    clientX: 16,
+    clientY: 36,
+    button: 0,
+    detail: 0,
+    timeStamp: 1,
+    shiftKey: false,
+    altKey: false,
+    ctrlKey: false,
+    metaKey: false,
+    preventDefault() {},
+    stopPropagation() {},
+  };
+}
+
+describe("desktop web mouse host", () => {
+  test("forwards mouse over handlers", () => {
+    let cellX = -1;
+    let cellY = -1;
+    const handlers = mouseHandlers({
+      onMouseOver: (event: { x: number; y: number }) => {
+        cellX = event.x;
+        cellY = event.y;
+      },
+    });
+
+    handlers.onMouseOver?.(fakeMouseEvent() as never);
+
+    expect(cellX).toBe(2);
+    expect(cellY).toBe(2);
+    expect(hasDirectMouseHandler({ onMouseOver: () => {} })).toBe(true);
+  });
+});

package/src/renderers/electrobun/view/host/mouse.ts

@@ -73,6 +73,7 @@ export function mouseHandlers(props: Record<string, unknown>) {
   );
   return {
     onMouseDown: wrap(props.onMouseDown),
+    onMouseOver: wrap(props.onMouseOver),
     onMouseMove: wrap(props.onMouseMove),
     onMouseUp: wrap(props.onMouseUp),
     onMouseOut: wrap(props.onMouseOut),
@@ -91,6 +92,7 @@ export function callCellMouseHandler(handler: unknown, event: CellMouseEvent): v
 
 export function hasDirectMouseHandler(props: Record<string, unknown>): boolean {
   return typeof props.onMouseDown === "function"
+    || typeof props.onMouseOver === "function"
     || typeof props.onMouseUp === "function"
     || typeof props.onMouseMove === "function"
     || typeof props.onMouseOut === "function"

package/src/renderers/electrobun/view/host/style.ts

@@ -104,6 +104,7 @@ export function cleanDomProps(props: Record<string, unknown>): Record<string, un
     "cursorColor", "selectionBg", "selectionFg", "showCursor", "keyBindings", "wrapText", "wrapMode",
     "initialValue", "value", "onInput", "onChange", "onSubmit", "onCursorChange", "onMouse",
     "scrollX", "scrollY", "focusable", "bitmap", "bitmaps", "crosshair", "text", "font",
+    "hoverBackgroundColor",
   ]) {
     delete next[key];
   }

package/src/renderers/electrobun/view/main.tsx

@@ -5,7 +5,7 @@ import { App } from "../../../app";
 import { UiHostProvider } from "../../../ui/host";
 import { debugLog } from "../../../utils/debug-log";
 import { measurePerfAsync } from "../../../utils/perf-marks";
-import { backendRequest, initElectrobunBackend } from "./backend-rpc";
+import { backendRequest, initElectrobunBackend, setElectrobunRemoteRequestHandler } from "./backend-rpc";
 import { installElectrobunAiHost } from "./ai-host";
 import { installElectrobunBrokerRemoteClient } from "./broker-remote-client";
 import { installElectrobunConfigStoreHost } from "./config-host";
@@ -89,6 +89,9 @@ async function boot() {
   const desktopWindowBridge = createDesktopWindowBridge(init.windowKind, init.paneId);
   const desktopApplicationMenuBridge = createApplicationMenuBridge();
   const webUiHost = createWebUiHost(init.desktopPlatform);
+  const remoteControlAdapter = init.windowKind === "main"
+    ? { registerHandler: setElectrobunRemoteRequestHandler }
+    : undefined;
   measurePerfAsync("startup.electrobun.root-render", async () => {
     root.render(
       <ElectrobunErrorBoundary>
@@ -102,6 +105,7 @@ async function boot() {
                   desktopApplicationMenuBridge={desktopApplicationMenuBridge}
                   desktopSnapshot={desktopSnapshot}
                   desktopThemePreview={init.desktopThemePreview}
+                  remoteControlAdapter={remoteControlAdapter}
                 />
               </WebDialogHostProvider>
             </WebToastHostProvider>