gloomberb 0.10.1 → 0.10.2

package/src/renderers/electrobun/bun/desktop/http-fetch.ts

@@ -1,3 +1,5 @@
+import type { DesktopBackendRequestPayload, DesktopHttpFetchResponse } from "../../shared/protocol";
+
 function normalizeHttpFetchHeaders(headers: unknown): Record<string, string> {
   if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
     return {};
@@ -8,7 +10,9 @@ function normalizeHttpFetchHeaders(headers: unknown): Record<string, string> {
   );
 }
 
-export async function handleHttpFetch(payload: Record<string, unknown>) {
+export async function handleHttpFetch(
+  payload: DesktopBackendRequestPayload<"http.fetch">,
+): Promise<DesktopHttpFetchResponse> {
   if (typeof payload.url !== "string") {
     throw new Error("http.fetch requires a URL.");
   }

package/src/renderers/electrobun/bun/desktop/initialization.ts

@@ -24,6 +24,7 @@ import {
   MAIN_WINDOW_RPC_KEY,
   paneIdFromDetachedRpcKey,
 } from "../window/focus";
+import type { DesktopBackendRequestPayload, ElectrobunBackendInit } from "../../shared/protocol";
 
 interface DesktopWindowTarget {
   kind: "main" | "detached";
@@ -39,7 +40,7 @@ interface InitializeDesktopBackendOptions<TRpc> {
   getSessionSnapshot: () => AppSessionSnapshot | null;
   getThemePreview: () => DesktopThemePreviewState;
   markWindowRpcReady: (rpc: TRpc) => void;
-  payload: Record<string, unknown>;
+  payload: DesktopBackendRequestPayload<"init">;
   reconcileDetachedWindows: () => void;
   registerCoreCapabilities: () => void;
   rpc: TRpc;
@@ -50,14 +51,14 @@ interface InitializeDesktopBackendOptions<TRpc> {
 }
 
 interface InitializationPayloadOptions {
-  desktopThemePreview?: DesktopThemePreviewState;
+  desktopThemePreview: DesktopThemePreviewState;
   getDesktopSnapshot: () => DesktopSharedStateSnapshot | null;
   getSessionSnapshot: () => AppSessionSnapshot | null;
 }
 
 function normalizeInitWindowTarget<TRpc>(
   rpc: TRpc,
-  payload: Record<string, unknown>,
+  payload: DesktopBackendRequestPayload<"init">,
   getRpcWindowKey: (rpc: TRpc) => string | undefined,
 ): DesktopWindowTarget {
   const rpcKey = getRpcWindowKey(rpc);
@@ -85,7 +86,7 @@ function buildInitializationPayload(
   services: AppServices,
   windowTarget: DesktopWindowTarget,
   options: InitializationPayloadOptions,
-) {
+): ElectrobunBackendInit {
   return {
     config,
     sessionSnapshot: options.getSessionSnapshot(),
@@ -109,7 +110,7 @@ async function resolveDesktopDataDir(): Promise<string> {
 
 export async function initializeDesktopBackend<TRpc>(
   options: InitializeDesktopBackendOptions<TRpc>,
-) {
+): Promise<ElectrobunBackendInit> {
   const windowTarget = normalizeInitWindowTarget(options.rpc, options.payload, options.getRpcWindowKey);
   options.markWindowRpcReady(options.rpc);
 
@@ -120,7 +121,11 @@ export async function initializeDesktopBackend<TRpc>(
       options.setDesktopWorkspace(createDesktopWorkspace(currentConfig, options.getSessionSnapshot()));
       options.reconcileDetachedWindows();
     }
-    return buildInitializationPayload(currentConfig, currentServices, windowTarget, options);
+    return buildInitializationPayload(currentConfig, currentServices, windowTarget, {
+      getDesktopSnapshot: options.getDesktopSnapshot,
+      getSessionSnapshot: options.getSessionSnapshot,
+      desktopThemePreview: options.getThemePreview(),
+    });
   }
 
   options.setCurrentConfig(await initDataDir(await resolveDesktopDataDir()));

package/src/renderers/electrobun/bun/desktop/media.ts

@@ -1,9 +1,11 @@
-import type { LiveStreamResolveRequest, ResolvedLiveStream } from "../../../../types/media";
+import type { ResolvedLiveStream } from "../../../../types/media";
 import { getTvChannel, TV_CHANNELS } from "../../../../plugins/builtin/tv/channels";
 import { resolveTvStream } from "../../../../plugins/builtin/tv/youtube-stream";
+import type { DesktopBackendRequestPayload } from "../../shared/protocol";
 
-export async function resolveDesktopLiveStream(payload: Record<string, unknown>): Promise<ResolvedLiveStream> {
-  const request = payload as Partial<LiveStreamResolveRequest>;
+export async function resolveDesktopLiveStream(
+  request: DesktopBackendRequestPayload<"media.resolveLiveStream">,
+): Promise<ResolvedLiveStream> {
   if (request.provider !== "youtube") {
     throw new Error("Unsupported live-stream provider.");
   }

package/src/renderers/electrobun/bun/desktop/plugin-state.ts

@@ -1,17 +1,11 @@
 import type { PluginRegistry } from "../../../../plugins/registry";
 import type { PersistedAuthUser } from "../../../../api-client";
 import { apiClient } from "../../../../api-client";
-
-interface PluginStateBackendSetEntry {
-  pluginId: string;
-  key: string;
-  value: unknown;
-  schemaVersion?: number;
-}
+import type { DesktopPluginStateRequest, DesktopPluginStateSetEntry } from "../../shared/protocol";
 
 interface PluginStateBackendStore {
   set(pluginId: string, key: string, value: unknown, schemaVersion?: number): void;
-  setMany(entries: PluginStateBackendSetEntry[]): void;
+  setMany(entries: DesktopPluginStateSetEntry[]): void;
   delete(pluginId: string, key: string): void;
 }
 
@@ -20,7 +14,7 @@ interface PersistedCloudSession {
   user?: PersistedAuthUser | null;
 }
 
-function normalizePluginStateSetEntry(entry: unknown): PluginStateBackendSetEntry | null {
+function normalizePluginStateSetEntry(entry: unknown): DesktopPluginStateSetEntry | null {
   if (!entry || typeof entry !== "object") return null;
   const record = entry as Record<string, unknown>;
   if (typeof record.pluginId !== "string" || typeof record.key !== "string") return null;
@@ -47,17 +41,18 @@ function syncBackendCloudAuthState(pluginId: string, key: string, value: unknown
 
 export function handleDesktopPluginStateRequest(
   store: PluginStateBackendStore,
-  method: string,
-  payload: Record<string, unknown>,
+  request: DesktopPluginStateRequest,
 ): null {
-  switch (method) {
-    case "pluginState.set":
-      store.set(payload.pluginId as string, payload.key as string, payload.value, payload.schemaVersion as number | undefined);
-      syncBackendCloudAuthState(payload.pluginId as string, payload.key as string, payload.value);
+  switch (request.method) {
+    case "pluginState.set": {
+      const { pluginId, key, value, schemaVersion } = request.payload;
+      store.set(pluginId, key, value, schemaVersion);
+      syncBackendCloudAuthState(pluginId, key, value);
       return null;
+    }
     case "pluginState.setMany": {
-      const entries = Array.isArray(payload.entries)
-        ? payload.entries.flatMap((entry) => {
+      const entries = Array.isArray(request.payload.entries)
+        ? request.payload.entries.flatMap((entry) => {
             const normalized = normalizePluginStateSetEntry(entry);
             return normalized ? [normalized] : [];
           })
@@ -68,12 +63,16 @@ export function handleDesktopPluginStateRequest(
       }
       return null;
     }
-    case "pluginState.delete":
-      store.delete(payload.pluginId as string, payload.key as string);
-      syncBackendCloudAuthState(payload.pluginId as string, payload.key as string, null);
+    case "pluginState.delete": {
+      const { pluginId, key } = request.payload;
+      store.delete(pluginId, key);
+      syncBackendCloudAuthState(pluginId, key, null);
       return null;
-    default:
-      throw new Error(`Unknown plugin state method: ${method}`);
+    }
+    default: {
+      const exhaustive: never = request;
+      throw new Error(`Unknown plugin state method: ${String(exhaustive)}`);
+    }
   }
 }
 

package/src/renderers/electrobun/bun/desktop/window-controls.ts

@@ -1,4 +1,6 @@
-export type DesktopWindowControlAction = "minimize" | "toggle-maximize" | "close";
+import type { DesktopWindowControlAction } from "../../shared/protocol";
+
+export type { DesktopWindowControlAction } from "../../shared/protocol";
 
 interface DesktopWindowFrame {
   x: number;

package/src/renderers/electrobun/bun/desktop/workspace/requests.ts

@@ -1,8 +1,8 @@
-import type { PaneRuntimeState } from "../../../../../core/state/app/state";
 import type {
   DesktopSharedStateSnapshot,
   DesktopThemePreviewState,
 } from "../../../../../types/desktop-window";
+import type { DesktopWorkspaceRequest } from "../../../shared/protocol";
 import type { DesktopWorkspace } from "./index";
 import type { WindowFrame } from "../../window/frame";
 
@@ -10,8 +10,7 @@ type DockEdge = "left" | "right" | "top" | "bottom";
 
 interface DesktopWorkspaceRequestOptions {
   workspace: DesktopWorkspace;
-  method: string;
-  payload: Record<string, unknown>;
+  request: DesktopWorkspaceRequest;
   setCurrentConfig: (config: DesktopSharedStateSnapshot["config"]) => void;
   sendThemePreview: (preview: DesktopThemePreviewState) => void;
   clearDockPreview: (paneId?: string) => void;
@@ -25,7 +24,7 @@ interface DesktopWorkspaceRequestOptions {
   focusDetachedPane: (paneId: string) => void;
 }
 
-function requirePaneId(payload: Record<string, unknown>, method: string): string {
+function requirePaneId(payload: { paneId: string }, method: string): string {
   if (typeof payload.paneId !== "string") {
     throw new Error(`${method} requires paneId.`);
   }
@@ -40,8 +39,7 @@ function normalizeDockEdge(edge: unknown): DockEdge | undefined {
 
 export async function handleDesktopWorkspaceRequest({
   workspace,
-  method,
-  payload,
+  request,
   setCurrentConfig,
   sendThemePreview,
   clearDockPreview,
@@ -51,47 +49,49 @@ export async function handleDesktopWorkspaceRequest({
   resolveDetachedFrame,
   focusDetachedPane,
 }: DesktopWorkspaceRequestOptions): Promise<null> {
-  switch (method) {
+  switch (request.method) {
     case "desktop.syncMainState": {
-      const snapshot = workspace.syncMainState(payload.snapshot as DesktopSharedStateSnapshot);
+      const snapshot = workspace.syncMainState(request.payload.snapshot);
       setCurrentConfig(snapshot.config);
       reconcileDetachedWindows();
       sendDesktopState(snapshot);
       return null;
     }
     case "desktop.setThemePreview":
-      sendThemePreview((payload.preview ?? { theme: null }) as DesktopThemePreviewState);
+      sendThemePreview(request.payload.preview ?? { theme: null });
       return null;
     case "desktop.replaceDetachedPaneState": {
-      const paneId = requirePaneId(payload, method);
-      sendDesktopState(workspace.replaceDetachedPaneState(paneId, payload.paneState as PaneRuntimeState));
+      const paneId = requirePaneId(request.payload, request.method);
+      sendDesktopState(workspace.replaceDetachedPaneState(paneId, request.payload.paneState));
       return null;
     }
     case "desktop.popOutPane": {
-      const paneId = requirePaneId(payload, method);
+      const paneId = requirePaneId(request.payload, request.method);
       const snapshot = workspace.popOutPane(paneId, resolveDetachedFrame(paneId));
       await commitDesktopSnapshot(snapshot);
       focusDetachedPane(paneId);
       return null;
     }
     case "desktop.dockDetachedPane": {
-      const paneId = requirePaneId(payload, method);
+      const paneId = requirePaneId(request.payload, request.method);
       clearDockPreview(paneId);
-      await commitDesktopSnapshot(workspace.dockDetachedPane(paneId, normalizeDockEdge(payload.edge)));
+      await commitDesktopSnapshot(workspace.dockDetachedPane(paneId, normalizeDockEdge(request.payload.edge)));
       return null;
     }
     case "desktop.closeDetachedPane": {
-      const paneId = requirePaneId(payload, method);
+      const paneId = requirePaneId(request.payload, request.method);
       clearDockPreview(paneId);
       await commitDesktopSnapshot(workspace.closeDetachedPane(paneId));
       return null;
     }
     case "desktop.focusDetachedPane": {
-      const paneId = requirePaneId(payload, method);
+      const paneId = requirePaneId(request.payload, request.method);
       focusDetachedPane(paneId);
       return null;
     }
-    default:
-      throw new Error(`Unknown desktop method: ${method}`);
+    default: {
+      const exhaustive: never = request;
+      throw new Error(`Unknown desktop method: ${String(exhaustive)}`);
+    }
   }
 }

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

@@ -12,7 +12,13 @@ import type { AppSessionSnapshot } from "../../../core/state/session-persistence
 import { syncConfigActiveLayoutState, type PaneRuntimeState } from "../../../core/state/app/state";
 import type { DesktopSharedStateSnapshot, DesktopThemePreviewState } from "../../../types/desktop-window";
 import type { UpdateProgress } from "../../../updater";
-import { ELECTROBUN_CONTEXT_MENU_ACTION, type DesktopRestartMessage, type ElectrobunDesktopRpcSchema } from "../shared/protocol";
+import {
+  ELECTROBUN_CONTEXT_MENU_ACTION,
+  type DesktopBackendRequest,
+  type DesktopBackendRequestPayload,
+  type DesktopRestartMessage,
+  type ElectrobunDesktopRpcSchema,
+} from "../shared/protocol";
 import { decodeRpcValue, encodeRpcValue } from "../view/rpc-codec";
 import { contextMenuSelectionMessage } from "./context-menu/click";
 import type { DesktopWorkspace } from "./desktop/workspace";
@@ -388,7 +394,7 @@ function controlWindowForRpcKey(windowKey: string | undefined, action: DesktopWi
 
 async function initialize(
   rpc: DesktopRpc,
-  payload: Record<string, unknown>,
+  payload: DesktopBackendRequestPayload<"init">,
 ) {
   const init = await initializeDesktopBackend({
     getCurrentConfig: () => currentConfig,
@@ -423,88 +429,116 @@ async function initialize(
 
 async function handleBackendRequest(
   rpc: DesktopRpc,
-  method: string,
-  rawPayload: unknown,
+  request: DesktopBackendRequest,
 ) {
-  const payload = decodeRpcValue<Record<string, unknown>>(rawPayload ?? {});
-
-  if (method === "init") return initialize(rpc, payload);
-  if (method === "http.fetch") return handleHttpFetch(payload);
-  if (method === "media.resolveLiveStream") return resolveDesktopLiveStream(payload);
-  if (method === "remote.forward") {
-    return forwardRemoteControlRequest(payload.request as RemoteControlRequest);
-  }
-  if (method.startsWith("capability.")) return capabilityBridge.handle(rpc, method, payload);
-  if (method.startsWith("desktop.")) {
-    return handleDesktopWorkspaceRequest({
-      workspace: requireDesktopWorkspace(),
-      method,
-      payload,
-      setCurrentConfig,
-      sendThemePreview,
-      clearDockPreview,
-      sendDesktopState,
-      reconcileDetachedWindows,
-      commitDesktopSnapshot,
-      resolveDetachedFrame: (paneId) => detachedWindowManager.resolveFrame(paneId),
-      focusDetachedPane: (paneId) => detachedWindowManager.focusDetachedPane(paneId),
-    });
-  }
-  if (method.startsWith("pluginState.")) {
-    return handleDesktopPluginStateRequest(requireServices().persistence.pluginState, method, payload);
-  }
-  if (method.startsWith("host.")) {
-    return handleDesktopHostRequest({
-      clearMainWindow: () => {
-        mainWindow = null;
-      },
-      closeAllDetachedWindows,
-      focusWindowForRpcKey: (windowKey) => detachedWindowManager.focusWindowForRpcKey(windowKey),
-      getMainWindow: () => mainWindow,
-      getRpcWindowKey,
-      method,
-      payload,
-      restartDesktopApp,
-      rpc,
-      teardownServices,
-      controlWindowForRpcKey,
-      trackContextMenuRequest: (requestId, targetRpc) => {
-        contextMenuRequestRpcs.clear();
-        contextMenuRequestRpcs.set(requestId, targetRpc);
-      },
-    });
+  switch (request.method) {
+    case "init":
+      return initialize(rpc, request.payload);
+    case "http.fetch":
+      return handleHttpFetch(request.payload);
+    case "media.resolveLiveStream":
+      return resolveDesktopLiveStream(request.payload);
+    case "remote.forward":
+      return forwardRemoteControlRequest(request.payload.request);
+    case "capability.invoke":
+    case "capability.subscribe":
+    case "capability.unsubscribe":
+      return capabilityBridge.handle(rpc, request);
+    case "desktop.syncMainState":
+    case "desktop.setThemePreview":
+    case "desktop.replaceDetachedPaneState":
+    case "desktop.popOutPane":
+    case "desktop.dockDetachedPane":
+    case "desktop.closeDetachedPane":
+    case "desktop.focusDetachedPane":
+      return handleDesktopWorkspaceRequest({
+        workspace: requireDesktopWorkspace(),
+        request,
+        setCurrentConfig,
+        sendThemePreview,
+        clearDockPreview,
+        sendDesktopState,
+        reconcileDetachedWindows,
+        commitDesktopSnapshot,
+        resolveDetachedFrame: (paneId) => detachedWindowManager.resolveFrame(paneId),
+        focusDetachedPane: (paneId) => detachedWindowManager.focusDetachedPane(paneId),
+      });
+    case "pluginState.set":
+    case "pluginState.setMany":
+    case "pluginState.delete":
+      return handleDesktopPluginStateRequest(requireServices().persistence.pluginState, request);
+    case "host.restart":
+    case "host.exit":
+    case "host.windowControl":
+    case "host.openExternal":
+    case "host.copyText":
+    case "host.focusWindow":
+    case "host.copyPngImage":
+    case "host.readText":
+    case "host.notify":
+    case "host.showContextMenu":
+      return handleDesktopHostRequest({
+        clearMainWindow: () => {
+          mainWindow = null;
+        },
+        closeAllDetachedWindows,
+        focusWindowForRpcKey: (windowKey) => detachedWindowManager.focusWindowForRpcKey(windowKey),
+        getMainWindow: () => mainWindow,
+        getRpcWindowKey,
+        request,
+        restartDesktopApp,
+        rpc,
+        teardownServices,
+        controlWindowForRpcKey,
+        trackContextMenuRequest: (requestId, targetRpc) => {
+          contextMenuRequestRpcs.clear();
+          contextMenuRequestRpcs.set(requestId, targetRpc);
+        },
+      });
+    case "update.check":
+    case "update.start":
+    case "ticker.loadAll":
+    case "ticker.load":
+    case "ticker.save":
+    case "ticker.delete":
+    case "config.save":
+    case "config.resetAllData":
+    case "config.export":
+    case "config.import":
+    case "session.set":
+    case "session.delete":
+      return handleDesktopBackendRequest({
+        clearCurrentConfig: () => {
+          currentConfig = null;
+        },
+        closeAllDetachedWindows,
+        commitDesktopSnapshot,
+        getConfig: requireConfig,
+        getDesktopWorkspace: () => desktopWorkspace,
+        getServices: requireServices,
+        getSessionSnapshot,
+        request,
+        reconcileDetachedWindows,
+        registerCoreCapabilities,
+        sendDesktopState,
+        setCurrentConfig,
+        setDesktopWorkspace: (workspace) => {
+          desktopWorkspace = workspace;
+        },
+        setServices: (nextServices) => {
+          services = nextServices;
+        },
+        startUpdate: (currentVersion) => {
+          void runDesktopUpdate(rpc, currentVersion);
+        },
+        syncConfigAccessors,
+        teardownServices,
+      });
+    default: {
+      const exhaustive: never = request;
+      throw new Error(`Unknown backend request: ${String(exhaustive)}`);
+    }
   }
-
-  const backendResult = await handleDesktopBackendRequest({
-    clearCurrentConfig: () => {
-      currentConfig = null;
-    },
-    closeAllDetachedWindows,
-    commitDesktopSnapshot,
-    getConfig: requireConfig,
-    getDesktopWorkspace: () => desktopWorkspace,
-    getServices: requireServices,
-    getSessionSnapshot,
-    method,
-    payload,
-    reconcileDetachedWindows,
-    registerCoreCapabilities,
-    sendDesktopState,
-    setCurrentConfig,
-    setDesktopWorkspace: (workspace) => {
-      desktopWorkspace = workspace;
-    },
-    setServices: (nextServices) => {
-      services = nextServices;
-    },
-    startUpdate: (currentVersion) => {
-      void runDesktopUpdate(rpc, currentVersion);
-    },
-    syncConfigAccessors,
-    teardownServices,
-  });
-  if (backendResult.handled) return backendResult.value;
-  throw new Error(`Unknown backend method: ${method}`);
 }
 
 function installApplicationMenu() {
@@ -516,7 +550,13 @@ function createWindowRpc(key: string): DesktopRpc {
   rpc = BrowserView.defineRPC<ElectrobunDesktopRpcSchema>({
     handlers: {
       requests: {
-        "backend.request": async ({ method, payload }) => encodeRpcValue(await handleBackendRequest(rpc, method, payload)),
+        "backend.request": async ({ method, payload }) => {
+          const request = {
+            method,
+            payload: decodeRpcValue(payload ?? null),
+          } as DesktopBackendRequest;
+          return encodeRpcValue(await handleBackendRequest(rpc, request));
+        },
       },
       messages: {
         "host.restart": (message) => {