@lobehub/lobehub 2.0.0-next.164 → 2.0.0-next.165

package/apps/desktop/src/main/utils/ipc/base.ts

@@ -0,0 +1,170 @@
+import type { IpcMainInvokeEvent, WebContents } from 'electron';
+import { ipcMain } from 'electron';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+// Base context for IPC methods
+export interface IpcContext {
+  event: IpcMainInvokeEvent;
+  sender: WebContents;
+}
+
+// Metadata storage for decorated methods
+const methodMetadata = new WeakMap<any, Map<string, string>>();
+const serverMethodMetadata = new WeakMap<any, Map<string, string>>();
+const ipcContextStorage = new AsyncLocalStorage<IpcContext>();
+
+// Decorator for IPC methods
+export function IpcMethod() {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const { constructor } = target;
+
+    if (!methodMetadata.has(constructor)) {
+      methodMetadata.set(constructor, new Map());
+    }
+
+    const methods = methodMetadata.get(constructor)!;
+    methods.set(propertyKey, propertyKey);
+
+    return descriptor;
+  };
+}
+
+export function IpcServerMethod(channelName?: string) {
+  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+    const { constructor } = target;
+
+    if (!serverMethodMetadata.has(constructor)) {
+      serverMethodMetadata.set(constructor, new Map());
+    }
+
+    const methods = serverMethodMetadata.get(constructor)!;
+    methods.set(propertyKey, channelName || propertyKey);
+
+    return descriptor;
+  };
+}
+
+// Handler registry for IPC methods
+export class IpcHandler {
+  private static instance: IpcHandler;
+  private registeredChannels = new Set<string>();
+
+  static getInstance(): IpcHandler {
+    if (!IpcHandler.instance) {
+      IpcHandler.instance = new IpcHandler();
+    }
+    return IpcHandler.instance;
+  }
+
+  registerMethod<TArgs extends unknown[], TOutput>(
+    channel: string,
+    handler: (...args: TArgs) => Promise<TOutput> | TOutput,
+  ) {
+    if (this.registeredChannels.has(channel)) {
+      return; // Already registered
+    }
+
+    this.registeredChannels.add(channel);
+
+    ipcMain.handle(channel, async (event: IpcMainInvokeEvent, ...args: any[]) => {
+      const context: IpcContext = {
+        event,
+        sender: event.sender,
+      };
+
+      return ipcContextStorage.run(context, async () => {
+        try {
+          const typedArgs = args as TArgs;
+          return await handler(...typedArgs);
+        } catch (error) {
+          console.error(`Error in IPC method ${channel}:`, error);
+          throw error;
+        }
+      });
+    });
+  }
+
+  // Send events to renderer
+  sendToRenderer<T = any>(webContents: WebContents, channel: string, data: T) {
+    webContents.send(channel, data);
+  }
+}
+
+// Base class for IPC service groups
+export abstract class IpcService {
+  protected handler = IpcHandler.getInstance();
+  static readonly groupName: string;
+
+  constructor() {
+    this.registerMethods();
+  }
+
+  protected registerMethods(): void {
+    const { constructor } = this;
+    const methods = methodMetadata.get(constructor);
+
+    if (methods) {
+      methods.forEach((methodName, propertyKey) => {
+        const method = (this as any)[propertyKey];
+        if (typeof method === 'function') {
+          this.registerMethod(methodName, method.bind(this));
+        }
+      });
+    }
+  }
+
+  protected registerMethod<TArgs extends unknown[], TOutput>(
+    methodName: string,
+    handler: (...args: TArgs) => Promise<TOutput> | TOutput,
+  ) {
+    const groupName = (this.constructor as typeof IpcService).groupName;
+    const channel = `${groupName}.${methodName}`;
+    this.handler.registerMethod(channel, handler);
+  }
+}
+
+// Service constructor with groupName
+export interface IpcServiceConstructor {
+  new (...args: any[]): IpcService;
+  readonly groupName: string;
+}
+
+// Create services function that infers types from service constructors
+export function createServices<T extends readonly IpcServiceConstructor[]>(
+  serviceConstructors: T,
+  ...constructorArgs: any[]
+): CreateServicesResult<T> {
+  const services = {} as any;
+
+  for (const ServiceConstructor of serviceConstructors) {
+    const instance = new ServiceConstructor(...constructorArgs);
+    const groupName = ServiceConstructor.groupName;
+
+    if (!groupName) {
+      throw new Error(
+        `Service ${ServiceConstructor.name} must define a static readonly groupName property`,
+      );
+    }
+
+    services[groupName] = instance;
+  }
+
+  return services;
+}
+
+// Helper type for createServices return type
+export type CreateServicesResult<T extends readonly IpcServiceConstructor[]> = {
+  [K in T[number] as K['groupName']]: InstanceType<K>;
+};
+
+export function getServerMethodMetadata(target: IpcServiceConstructor) {
+  return serverMethodMetadata.get(target);
+}
+
+export function getIpcContext() {
+  return ipcContextStorage.getStore();
+}
+
+export function runWithIpcContext<T>(context: IpcContext, callback: () => T): T {
+  return ipcContextStorage.run(context, callback);
+}

package/apps/desktop/src/main/utils/ipc/index.ts

@@ -0,0 +1,11 @@
+export type { CreateServicesResult, IpcContext, IpcServiceConstructor } from './base';
+export {
+  createServices,
+  getIpcContext,
+  getServerMethodMetadata,
+  IpcMethod,
+  IpcServerMethod,
+  IpcService,
+  runWithIpcContext,
+} from './base';
+export type { ExtractServiceMethods, MergeIpcService } from './utility';

package/apps/desktop/src/main/utils/ipc/utility.ts

@@ -0,0 +1,20 @@
+// Extract method signatures from service classes
+type ExtractMethodSignature<T> = T extends (...args: infer Args) => infer Output
+  ? (...args: Args) => AlwaysPromise<Output>
+  : never;
+
+export type ExtractServiceMethods<T> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: ExtractMethodSignature<T[K]>;
+};
+
+type AlwaysPromise<T> = Promise<Awaited<T>>;
+
+// TypeScript utility type to automatically merge IPC services
+// This version works with both the old object format and new createServices format
+export type MergeIpcService<T> = {
+  [K in keyof T]: T[K] extends new (...args: any[]) => infer Instance
+    ? ExtractServiceMethods<Instance>
+    : T[K] extends infer Instance
+      ? ExtractServiceMethods<Instance>
+      : never;
+};

package/apps/desktop/src/preload/electronApi.ts

@@ -15,5 +15,8 @@ export const setupElectronApi = () => {
     console.error(error);
   }
 
-  contextBridge.exposeInMainWorld('electronAPI', { invoke, onStreamInvoke });
+  contextBridge.exposeInMainWorld('electronAPI', {
+    invoke,
+    onStreamInvoke,
+  });
 };

package/apps/desktop/src/preload/invoke.test.ts

@@ -1,4 +1,3 @@
-import { ClientDispatchEventKey } from '@lobechat/electron-client-ipc';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 // Mock electron module
@@ -21,9 +20,9 @@ describe('invoke', () => {
     const expectedResult = { success: true };
     mockIpcRendererInvoke.mockResolvedValue(expectedResult);
 
-    const result = await invoke('getAppVersion' as ClientDispatchEventKey);
+    const result = await invoke('system.getAppVersion');
 
-    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('getAppVersion');
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('system.getAppVersion');
     expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(1);
     expect(result).toEqual(expectedResult);
   });
@@ -33,9 +32,9 @@ describe('invoke', () => {
     const expectedResult = { navigated: true };
     mockIpcRendererInvoke.mockResolvedValue(expectedResult);
 
-    const result = await invoke('interceptRoute' as ClientDispatchEventKey, eventData);
+    const result = await invoke('windows.interceptRoute', eventData);
 
-    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('interceptRoute', eventData);
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('windows.interceptRoute', eventData);
     expect(mockIpcRendererInvoke).toHaveBeenCalledTimes(1);
     expect(result).toEqual(expectedResult);
   });
@@ -59,16 +58,14 @@ describe('invoke', () => {
     const error = new Error('IPC communication failed');
     mockIpcRendererInvoke.mockRejectedValue(error);
 
-    await expect(invoke('getAppVersion' as ClientDispatchEventKey)).rejects.toThrow(
-      'IPC communication failed',
-    );
-    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('getAppVersion');
+    await expect(invoke('system.getAppVersion')).rejects.toThrow('IPC communication failed');
+    expect(mockIpcRendererInvoke).toHaveBeenCalledWith('system.getAppVersion');
   });
 
   it('should handle ipcRenderer returning undefined', async () => {
     mockIpcRendererInvoke.mockResolvedValue(undefined);
 
-    const result = await invoke('someEvent' as ClientDispatchEventKey);
+    const result = await invoke('someEvent');
 
     expect(mockIpcRendererInvoke).toHaveBeenCalledWith('someEvent');
     expect(result).toBeUndefined();
@@ -77,7 +74,7 @@ describe('invoke', () => {
   it('should handle ipcRenderer returning null', async () => {
     mockIpcRendererInvoke.mockResolvedValue(null);
 
-    const result = await invoke('someEvent' as ClientDispatchEventKey);
+    const result = await invoke('someEvent');
 
     expect(mockIpcRendererInvoke).toHaveBeenCalledWith('someEvent');
     expect(result).toBeNull();
@@ -96,7 +93,7 @@ describe('invoke', () => {
     };
     mockIpcRendererInvoke.mockResolvedValue(complexData);
 
-    const result = await invoke('getData' as ClientDispatchEventKey);
+    const result = await invoke('getData');
 
     expect(result).toEqual(complexData);
   });
@@ -125,9 +122,9 @@ describe('invoke', () => {
       .mockResolvedValueOnce({ id: 3 });
 
     const [result1, result2, result3] = await Promise.all([
-      invoke('event1' as ClientDispatchEventKey),
-      invoke('event2' as ClientDispatchEventKey),
-      invoke('event3' as ClientDispatchEventKey),
+      invoke('event1'),
+      invoke('event2'),
+      invoke('event3'),
     ]);
 
     expect(result1).toEqual({ id: 1 });
@@ -139,7 +136,7 @@ describe('invoke', () => {
   it('should handle empty string as data parameter', async () => {
     mockIpcRendererInvoke.mockResolvedValue({ received: '' });
 
-    const result = await invoke('sendData' as ClientDispatchEventKey, '');
+    const result = await invoke('sendData', '');
 
     expect(mockIpcRendererInvoke).toHaveBeenCalledWith('sendData', '');
     expect(result).toEqual({ received: '' });

package/apps/desktop/src/preload/invoke.ts

@@ -1,10 +1,7 @@
-import { ClientDispatchEventKey, DispatchInvoke } from '@lobechat/electron-client-ipc';
+import { DispatchInvoke } from '@lobechat/electron-client-ipc';
 import { ipcRenderer } from 'electron';
 
 /**
  * Client-side method to invoke electron main process
  */
-export const invoke: DispatchInvoke = async <T extends ClientDispatchEventKey>(
-  event: T,
-  ...data: any[]
-) => ipcRenderer.invoke(event, ...data);
+export const invoke: DispatchInvoke = async (event, ...data) => ipcRenderer.invoke(event, ...data);

package/apps/desktop/src/preload/routeInterceptor.test.ts

@@ -46,7 +46,7 @@ describe('setupRouteInterceptors', () => {
       const externalUrl = 'https://google.com';
       const result = window.open(externalUrl, '_blank');
 
-      expect(invoke).toHaveBeenCalledWith('openExternalLink', externalUrl);
+      expect(invoke).toHaveBeenCalledWith('system.openExternalLink', externalUrl);
       expect(result).toBeNull();
     });
 
@@ -56,7 +56,7 @@ describe('setupRouteInterceptors', () => {
       const externalUrl = new URL('https://github.com');
       const result = window.open(externalUrl, '_blank');
 
-      expect(invoke).toHaveBeenCalledWith('openExternalLink', 'https://github.com/');
+      expect(invoke).toHaveBeenCalledWith('system.openExternalLink', 'https://github.com/');
       expect(result).toBeNull();
     });
 
@@ -69,7 +69,7 @@ describe('setupRouteInterceptors', () => {
       // We can't fully test the original behavior in happy-dom, but we can verify invoke is not called
       window.open(internalUrl);
 
-      expect(invoke).not.toHaveBeenCalledWith('openExternalLink', expect.anything());
+      expect(invoke).not.toHaveBeenCalledWith('system.openExternalLink', expect.anything());
     });
 
     it('should handle relative URL that resolves as internal link', () => {
@@ -81,7 +81,7 @@ describe('setupRouteInterceptors', () => {
       window.open(relativeUrl);
 
       // Since it's internal, it won't call invoke for external link
-      expect(invoke).not.toHaveBeenCalledWith('openExternalLink', expect.anything());
+      expect(invoke).not.toHaveBeenCalledWith('system.openExternalLink', expect.anything());
     });
   });
 
@@ -102,7 +102,7 @@ describe('setupRouteInterceptors', () => {
       // Wait for async handling
       await new Promise((resolve) => setTimeout(resolve, 0));
 
-      expect(invoke).toHaveBeenCalledWith('openExternalLink', 'https://example.com/');
+      expect(invoke).toHaveBeenCalledWith('system.openExternalLink', 'https://example.com/');
       expect(preventDefaultSpy).toHaveBeenCalled();
       expect(stopPropagationSpy).toHaveBeenCalled();
     });
@@ -129,7 +129,7 @@ describe('setupRouteInterceptors', () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
 
       expect(findMatchingRoute).toHaveBeenCalledWith('/desktop/devtools');
-      expect(invoke).toHaveBeenCalledWith('interceptRoute', {
+      expect(invoke).toHaveBeenCalledWith('windows.interceptRoute', {
         path: '/desktop/devtools',
         source: 'link-click',
         url: 'http://localhost:3000/desktop/devtools',
@@ -166,7 +166,7 @@ describe('setupRouteInterceptors', () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
 
       expect(preventDefaultSpy).not.toHaveBeenCalled();
-      expect(invoke).not.toHaveBeenCalledWith('interceptRoute', expect.anything());
+      expect(invoke).not.toHaveBeenCalledWith('windows.interceptRoute', expect.anything());
     });
 
     it('should handle non-HTTP link protocols as external links', async () => {
@@ -184,7 +184,7 @@ describe('setupRouteInterceptors', () => {
       await new Promise((resolve) => setTimeout(resolve, 0));
 
       // mailto: links are treated as external links by the URL constructor
-      expect(invoke).toHaveBeenCalledWith('openExternalLink', 'mailto:test@example.com');
+      expect(invoke).toHaveBeenCalledWith('system.openExternalLink', 'mailto:test@example.com');
       expect(preventDefaultSpy).toHaveBeenCalled();
     });
   });
@@ -205,7 +205,7 @@ describe('setupRouteInterceptors', () => {
       history.pushState({}, '', '/desktop/devtools');
 
       expect(findMatchingRoute).toHaveBeenCalledWith('/desktop/devtools');
-      expect(invoke).toHaveBeenCalledWith('interceptRoute', {
+      expect(invoke).toHaveBeenCalledWith('windows.interceptRoute', {
         path: '/desktop/devtools',
         source: 'push-state',
         url: 'http://localhost:3000/desktop/devtools',
@@ -245,7 +245,7 @@ describe('setupRouteInterceptors', () => {
 
       history.pushState({}, '', '/chat/new');
 
-      expect(invoke).not.toHaveBeenCalledWith('interceptRoute', expect.anything());
+      expect(invoke).not.toHaveBeenCalledWith('windows.interceptRoute', expect.anything());
     });
 
     it('should handle pushState errors gracefully', () => {
@@ -279,7 +279,7 @@ describe('setupRouteInterceptors', () => {
       history.replaceState({}, '', '/desktop/devtools');
 
       expect(findMatchingRoute).toHaveBeenCalledWith('/desktop/devtools');
-      expect(invoke).toHaveBeenCalledWith('interceptRoute', {
+      expect(invoke).toHaveBeenCalledWith('windows.interceptRoute', {
         path: '/desktop/devtools',
         source: 'replace-state',
         url: 'http://localhost:3000/desktop/devtools',
@@ -317,7 +317,7 @@ describe('setupRouteInterceptors', () => {
 
       history.replaceState({}, '', '/chat/session-123');
 
-      expect(invoke).not.toHaveBeenCalledWith('interceptRoute', expect.anything());
+      expect(invoke).not.toHaveBeenCalledWith('windows.interceptRoute', expect.anything());
     });
   });
 
@@ -385,7 +385,7 @@ describe('setupRouteInterceptors', () => {
 
       await new Promise((resolve) => setTimeout(resolve, 0));
 
-      expect(invoke).toHaveBeenCalledWith('interceptRoute', {
+      expect(invoke).toHaveBeenCalledWith('windows.interceptRoute', {
         path: '/desktop/devtools',
         source: 'push-state',
         url: 'http://localhost:3000/desktop/devtools',

package/apps/desktop/src/preload/routeInterceptor.ts

@@ -11,7 +11,7 @@ const interceptRoute = async (
 
   // Use electron-client-ipc's dispatch method
   try {
-    await invoke('interceptRoute', { path, source, url });
+    await invoke('windows.interceptRoute', { path, source, url });
   } catch (e) {
     console.error(`[preload] Route interception (${source}) call failed`, e);
   }
@@ -37,14 +37,14 @@ export const setupRouteInterceptors = function () {
         if (urlObj.origin !== window.location.origin) {
           console.log(`[preload] Intercepted window.open for external URL:`, urlString);
           // Call main process to handle external link
-          invoke('openExternalLink', urlString);
+          invoke('system.openExternalLink', urlString);
           return null; // Return null to indicate no window was opened
         }
       } catch (error) {
         // Handle invalid URL or special protocol
         console.error(`[preload] Intercepted window.open for special protocol:`, url);
         console.error(error);
-        invoke('openExternalLink', typeof url === 'string' ? url : url.toString());
+        invoke('system.openExternalLink', typeof url === 'string' ? url : url.toString());
         return null;
       }
     }
@@ -69,7 +69,7 @@ export const setupRouteInterceptors = function () {
             e.preventDefault();
             e.stopPropagation();
             // Call main process to handle external link
-            await invoke('openExternalLink', url.href);
+            await invoke('system.openExternalLink', url.href);
             return false; // Explicitly prevent subsequent processing
           }
 

package/apps/desktop/tsconfig.json

@@ -3,18 +3,28 @@
     "allowJs": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
     "target": "ESNext",
+    "emitDeclarationOnly": true,
     "esModuleInterop": true,
     "emitDecoratorMetadata": true,
+    "composite": true,
+    "baseUrl": ".",
     "experimentalDecorators": true,
     "module": "esnext",
     "moduleResolution": "bundler",
     "resolveJsonModule": true,
     "paths": {
-      "@/*": ["src/main/*"],
-      "~common/*": ["src/common/*"]
+      "@/*": [
+        "src/main/*"
+      ],
+      "~common/*": [
+        "src/common/*"
+      ]
     }
   },
-  "include": ["src/main/**/*", "src/preload/**/*", "electron-builder.js"]
-}
+  "include": [
+    "src/main/**/*",
+    "src/preload/**/*",
+    "electron-builder.js"
+  ]
+}

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2025-12-09",
+    "version": "2.0.0-next.165"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.164",
+  "version": "2.0.0-next.165",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -27,7 +27,8 @@
   "sideEffects": false,
   "workspaces": [
     "packages/*",
-    "e2e"
+    "e2e",
+    "apps/desktop/src/main"
   ],
   "scripts": {
     "prebuild": "tsx scripts/prebuild.mts && npm run lint",
@@ -169,6 +170,7 @@
     "@lobehub/charts": "^2.1.2",
     "@lobehub/chat-plugin-sdk": "^1.32.4",
     "@lobehub/chat-plugins-gateway": "^1.9.0",
+    "@lobehub/desktop-ipc-typings": "workspace:*",
     "@lobehub/editor": "^1.23.1",
     "@lobehub/icons": "^2.43.1",
     "@lobehub/market-sdk": "^0.23.2",
@@ -338,7 +340,6 @@
     "@types/crypto-js": "^4.2.2",
     "@types/debug": "^4.1.12",
     "@types/fs-extra": "^11.0.4",
-    "@types/ioredis": "^5.0.0",
     "@types/ip": "^1.1.3",
     "@types/json-schema": "^7.0.15",
     "@types/lodash": "^4.17.21",

package/packages/electron-client-ipc/src/index.ts

@@ -1,5 +1,5 @@
-export * from './dispatch';
 export * from './events';
+export * from './ipc';
 export * from './streamInvoke';
 export * from './types';
 export * from './useWatchBroadcast';

package/packages/electron-client-ipc/src/ipc.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const restoreWindow = (() => {
+  const originalWindow = (globalThis as any).window;
+
+  return () => {
+    if (originalWindow === undefined) {
+      Reflect.deleteProperty(globalThis as any, 'window');
+      return;
+    }
+    (globalThis as any).window = originalWindow;
+  };
+})();
+
+describe('getElectronIpc', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    restoreWindow();
+  });
+
+  afterEach(() => {
+    restoreWindow();
+  });
+
+  it('returns null when window is not defined', async () => {
+    Reflect.deleteProperty(globalThis as any, 'window');
+    const { getElectronIpc } = await import('./ipc');
+
+    expect(getElectronIpc()).toBeNull();
+  });
+
+  it('returns null when invoke is missing on electronAPI', async () => {
+    (globalThis as any).window = { electronAPI: {} };
+    const { getElectronIpc } = await import('./ipc');
+
+    expect(getElectronIpc()).toBeNull();
+  });
+
+  it('creates a cached proxy and forwards payloads to invoke', async () => {
+    const invoke = vi.fn();
+    (globalThis as any).window = {
+      electronAPI: {
+        invoke,
+        onStreamInvoke: vi.fn(),
+      },
+    };
+
+    const { getElectronIpc } = await import('./ipc');
+
+    const ipc = getElectronIpc();
+    expect(ipc).not.toBeNull();
+
+    await (ipc as any).system.updateLocale('en-US');
+    expect(invoke).toHaveBeenCalledWith('system.updateLocale', 'en-US');
+
+    await (ipc as any).windows.closeWindow();
+    expect(invoke).toHaveBeenCalledWith('windows.closeWindow');
+
+    const cached = getElectronIpc();
+    expect(cached).toBe(ipc);
+  });
+});

package/packages/electron-client-ipc/src/ipc.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/no-empty-interface */
+import type { DispatchInvoke } from './types/dispatch';
+import type { ProxyTRPCRequestParams } from './types/proxyTRPCRequest';
+
+interface StreamerCallbacks {
+  onData: (chunk: Uint8Array) => void;
+  onEnd: () => void;
+  onError: (error: Error) => void;
+  onResponse: (response: {
+    headers: Record<string, string>;
+    status: number;
+    statusText: string;
+  }) => void;
+}
+
+export interface DesktopIpcServicesMap {}
+export type DesktopIpcServices = DesktopIpcServicesMap;
+export type ElectronDesktopIpc = DesktopIpcServices | null;
+
+const createInvokeProxy = <IpcServices>(invoke: DispatchInvoke): IpcServices =>
+  new Proxy(
+    {},
+    {
+      get(_target, groupKey) {
+        if (typeof groupKey !== 'string') return undefined;
+
+        return new Proxy(
+          {},
+          {
+            get(_methodTarget, methodKey) {
+              if (typeof methodKey !== 'string') return undefined;
+
+              const channel = `${groupKey}.${methodKey}`;
+              return (payload?: unknown) =>
+                payload === undefined ? invoke(channel) : invoke(channel, payload);
+            },
+          },
+        );
+      },
+    },
+  ) as IpcServices;
+
+let cachedProxy: DesktopIpcServices | null = null;
+
+declare global {
+  interface Window {
+    electronAPI?: {
+      invoke?: DispatchInvoke;
+      onStreamInvoke: (params: ProxyTRPCRequestParams, callbacks: StreamerCallbacks) => () => void;
+    };
+  }
+}
+
+export const getElectronIpc = (): DesktopIpcServices | null => {
+  if (typeof window === 'undefined') return null;
+  if (cachedProxy) return cachedProxy;
+
+  const invoke = window.electronAPI?.invoke;
+  if (!invoke) return null;
+
+  cachedProxy = createInvokeProxy<DesktopIpcServices>(invoke);
+  return cachedProxy;
+};