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

package/src/server/modules/ElectronIPCClient/index.ts

@@ -1,46 +1,92 @@
 import { CreateFileParams, ElectronIpcClient, FileMetadata } from '@lobechat/electron-server-ipc';
+import type { DesktopServerIpcServices } from '@lobehub/desktop-ipc-typings';
 
 import packageJSON from '@/../apps/desktop/package.json';
 
+const createServerInvokeProxy = <IpcServices>(
+  invoke: (channel: string, payload?: unknown) => Promise<unknown>,
+): 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;
+
 class LobeHubElectronIpcClient extends ElectronIpcClient {
-  // 获取数据库路径
+  private _services: DesktopServerIpcServices | null = null;
+
+  private ensureServices(): DesktopServerIpcServices {
+    if (this._services) return this._services;
+
+    this._services = createServerInvokeProxy<DesktopServerIpcServices>((channel, payload) =>
+      payload === undefined ? this.sendRequest(channel) : this.sendRequest(channel, payload),
+    );
+
+    return this.services;
+  }
+
+  private get ipc() {
+    return this.ensureServices();
+  }
+
+  public get services(): DesktopServerIpcServices {
+    return this.ipc;
+  }
+
   getDatabasePath = async (): Promise<string> => {
-    return this.sendRequest<string>('getDatabasePath');
+    return this.ipc.system.getDatabasePath();
   };
 
-  // 获取用户数据路径
   getUserDataPath = async (): Promise<string> => {
-    return this.sendRequest<string>('getUserDataPath');
+    return this.ipc.system.getUserDataPath();
   };
 
   getDatabaseSchemaHash = async () => {
-    return this.sendRequest<string>('setDatabaseSchemaHash');
+    return this.ipc.system.getDatabaseSchemaHash();
   };
 
   setDatabaseSchemaHash = async (hash: string | undefined) => {
     if (!hash) return;
 
-    return this.sendRequest('setDatabaseSchemaHash', hash);
+    return this.ipc.system.setDatabaseSchemaHash(hash);
   };
 
   getFilePathById = async (id: string) => {
-    return this.sendRequest<string>('getStaticFilePath', id);
+    return this.ipc.upload.getFileUrlById(id);
   };
 
   getFileHTTPURL = async (path: string) => {
-    return this.sendRequest<string>('getFileHTTPURL', path);
+    return this.ipc.upload.getFileHTTPURL(path);
   };
 
   deleteFiles = async (paths: string[]) => {
-    return this.sendRequest<{ errors?: { message: string; path: string }[]; success: boolean }>(
-      'deleteFiles',
-      paths,
-    );
+    return this.ipc.upload.deleteFiles(paths);
   };
 
   createFile = async (params: CreateFileParams) => {
-    return this.sendRequest<{ metadata: FileMetadata; success: boolean }>('createFile', params);
+    return this.ipc.upload.createFile(params) as Promise<{
+      metadata: FileMetadata;
+      success: boolean;
+    }>;
   };
 }
 
 export const electronIpcClient = new LobeHubElectronIpcClient(packageJSON.name);
+
+export const ensureElectronServerIpc = (): DesktopServerIpcServices => electronIpcClient.services;

package/src/services/electron/__tests__/devtools.test.ts

@@ -1,11 +1,14 @@
-import { dispatch } from '@lobechat/electron-client-ipc';
 import { describe, expect, it, vi } from 'vitest';
 
 import { electronDevtoolsService } from '../devtools';
 
-vi.mock('@lobechat/electron-client-ipc', () => ({
-  dispatch: vi.fn(),
+const openDevtoolsMock = vi.fn();
+vi.mock('@/utils/electron/ipc', () => ({
+  ensureElectronIpc: vi.fn(() => ({
+    devtools: { openDevtools: openDevtoolsMock },
+  })),
 }));
+const { ensureElectronIpc } = await import('@/utils/electron/ipc');
 
 describe('DevtoolsService', () => {
   beforeEach(() => {
@@ -15,18 +18,19 @@ describe('DevtoolsService', () => {
   describe('openDevtools', () => {
     it('should call dispatch with openDevtools', async () => {
       await electronDevtoolsService.openDevtools();
-      expect(dispatch).toHaveBeenCalledWith('openDevtools');
+      expect(ensureElectronIpc).toHaveBeenCalled();
+      expect(openDevtoolsMock).toHaveBeenCalled();
     });
 
     it('should return void when dispatch succeeds', async () => {
-      vi.mocked(dispatch).mockResolvedValueOnce();
+      openDevtoolsMock.mockResolvedValueOnce(undefined);
       const result = await electronDevtoolsService.openDevtools();
       expect(result).toBeUndefined();
     });
 
     it('should throw error when dispatch fails', async () => {
       const error = new Error('Failed to open devtools');
-      vi.mocked(dispatch).mockRejectedValueOnce(error);
+      openDevtoolsMock.mockRejectedValueOnce(error);
 
       await expect(electronDevtoolsService.openDevtools()).rejects.toThrow(error);
     });

package/src/services/electron/autoUpdate.ts

@@ -1,20 +1,20 @@
-import { dispatch } from '@lobechat/electron-client-ipc';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class AutoUpdateService {
   checkUpdate = async () => {
-    return dispatch('checkUpdate');
+    return ensureElectronIpc().autoUpdate.checkForUpdates();
   };
 
   installNow = async () => {
-    return dispatch('installNow');
+    return ensureElectronIpc().autoUpdate.quitAndInstallUpdate();
   };
 
   installLater = async () => {
-    return dispatch('installLater');
+    return ensureElectronIpc().autoUpdate.installLater();
   };
 
   downloadUpdate() {
-    return dispatch('downloadUpdate');
+    return ensureElectronIpc().autoUpdate.downloadUpdate();
   }
 }
 

package/src/services/electron/desktopNotification.ts

@@ -1,8 +1,5 @@
-import {
-  DesktopNotificationResult,
-  ShowDesktopNotificationParams,
-  dispatch,
-} from '@lobechat/electron-client-ipc';
+import { DesktopNotificationResult, ShowDesktopNotificationParams } from '@lobechat/electron-client-ipc';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 /**
  * Desktop notification service
@@ -16,7 +13,7 @@ export class DesktopNotificationService {
   async showNotification(
     params: ShowDesktopNotificationParams,
   ): Promise<DesktopNotificationResult> {
-    return dispatch('showDesktopNotification', params);
+    return ensureElectronIpc().notification.showDesktopNotification(params);
   }
 
   /**
@@ -24,7 +21,7 @@ export class DesktopNotificationService {
    * @returns Whether it is hidden
    */
   async isMainWindowHidden(): Promise<boolean> {
-    return dispatch('isMainWindowHidden');
+    return ensureElectronIpc().notification.isMainWindowHidden();
   }
 }
 

package/src/services/electron/devtools.ts

@@ -1,8 +1,8 @@
-import { dispatch } from '@lobechat/electron-client-ipc';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class DevtoolsService {
   async openDevtools(): Promise<void> {
-    return dispatch('openDevtools');
+    return ensureElectronIpc().devtools.openDevtools();
   }
 }
 

package/src/services/electron/file.ts

@@ -1,6 +1,7 @@
-import { dispatch } from '@lobechat/electron-client-ipc';
 import { FileMetadata } from '@lobechat/types';
 
+import { ensureElectronIpc } from '@/utils/electron/ipc';
+
 /**
  * Desktop application file API client service
  */
@@ -19,7 +20,7 @@ class DesktopFileAPI {
   ): Promise<{ metadata: FileMetadata; success: boolean }> {
     const arrayBuffer = await file.arrayBuffer();
 
-    return dispatch('createFile', {
+    return ensureElectronIpc().upload.uploadFile({
       content: arrayBuffer,
       filename: file.name,
       hash,

package/src/services/electron/localFileService.ts

@@ -23,71 +23,72 @@ import {
   RunCommandParams,
   RunCommandResult,
   WriteLocalFileParams,
-  dispatch,
 } from '@lobechat/electron-client-ipc';
 
+import { ensureElectronIpc } from '@/utils/electron/ipc';
+
 class LocalFileService {
   // File Operations
   async listLocalFiles(params: ListLocalFileParams): Promise<LocalFileItem[]> {
-    return dispatch('listLocalFiles', params);
+    return ensureElectronIpc().localSystem.listLocalFiles(params);
   }
 
   async readLocalFile(params: LocalReadFileParams): Promise<LocalReadFileResult> {
-    return dispatch('readLocalFile', params);
+    return ensureElectronIpc().localSystem.readFile(params);
   }
 
   async readLocalFiles(params: LocalReadFilesParams): Promise<LocalReadFileResult[]> {
-    return dispatch('readLocalFiles', params);
+    return ensureElectronIpc().localSystem.readFiles(params);
   }
 
   async searchLocalFiles(params: LocalSearchFilesParams): Promise<LocalFileItem[]> {
-    return dispatch('searchLocalFiles', params);
+    return ensureElectronIpc().localSystem.handleLocalFilesSearch(params);
   }
 
   async openLocalFile(params: OpenLocalFileParams) {
-    return dispatch('openLocalFile', params);
+    return ensureElectronIpc().localSystem.handleOpenLocalFile(params);
   }
 
   async openLocalFolder(params: OpenLocalFolderParams) {
-    return dispatch('openLocalFolder', params);
+    return ensureElectronIpc().localSystem.handleOpenLocalFile(params);
   }
 
   async moveLocalFiles(params: MoveLocalFilesParams): Promise<LocalMoveFilesResultItem[]> {
-    return dispatch('moveLocalFiles', params);
+    return ensureElectronIpc().localSystem.handleMoveFiles(params);
   }
 
   async renameLocalFile(params: RenameLocalFileParams) {
-    return dispatch('renameLocalFile', params);
+    return ensureElectronIpc().localSystem.handleRenameFile(params);
   }
 
   async writeFile(params: WriteLocalFileParams) {
-    return dispatch('writeLocalFile', params);
+    return ensureElectronIpc().localSystem.handleWriteFile(params);
   }
 
   async editLocalFile(params: EditLocalFileParams): Promise<EditLocalFileResult> {
-    return dispatch('editLocalFile', params);
+    return ensureElectronIpc().localSystem.handleEditFile(params);
   }
 
   // Shell Commands
   async runCommand(params: RunCommandParams): Promise<RunCommandResult> {
-    return dispatch('runCommand', params);
+    return ensureElectronIpc().shellCommand.handleRunCommand(params);
   }
 
   async getCommandOutput(params: GetCommandOutputParams): Promise<GetCommandOutputResult> {
-    return dispatch('getCommandOutput', params);
+    return ensureElectronIpc().shellCommand.handleGetCommandOutput(params);
   }
 
   async killCommand(params: KillCommandParams): Promise<KillCommandResult> {
-    return dispatch('killCommand', params);
+    return ensureElectronIpc().shellCommand.handleKillCommand(params);
   }
 
   // Search & Find
   async grepContent(params: GrepContentParams): Promise<GrepContentResult> {
-    return dispatch('grepContent', params);
+    return ensureElectronIpc().localSystem.handleGrepContent(params);
   }
 
   async globFiles(params: GlobFilesParams): Promise<GlobFilesResult> {
-    return dispatch('globLocalFiles', params);
+    return ensureElectronIpc().localSystem.handleGlobFiles(params);
   }
 
   // Helper methods

package/src/services/electron/remoteServer.ts

@@ -1,39 +1,40 @@
-import { DataSyncConfig, MarketAuthorizationParams, dispatch } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, MarketAuthorizationParams } from '@lobechat/electron-client-ipc';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class RemoteServerService {
   /**
    * Get remote server configuration
    */
   getRemoteServerConfig = async () => {
-    return dispatch('getRemoteServerConfig');
+    return ensureElectronIpc().remoteServer.getRemoteServerConfig();
   };
 
   /**
    * Set remote server configuration
    */
   setRemoteServerConfig = async (config: DataSyncConfig) => {
-    return dispatch('setRemoteServerConfig', config);
+    return ensureElectronIpc().remoteServer.setRemoteServerConfig(config);
   };
 
   /**
    * Clear remote server configuration
    */
   clearRemoteServerConfig = async () => {
-    return dispatch('clearRemoteServerConfig');
+    return ensureElectronIpc().remoteServer.clearRemoteServerConfig();
   };
 
   /**
    * Request authorization
    */
   requestAuthorization = async (config: DataSyncConfig) => {
-    return dispatch('requestAuthorization', config);
+    return ensureElectronIpc().auth.requestAuthorization(config);
   };
 
   /**
    * Request Market authorization
    */
   requestMarketAuthorization = async (params: MarketAuthorizationParams) => {
-    return dispatch('requestMarketAuthorization', params);
+    return ensureElectronIpc().auth.requestMarketAuthorization(params);
   };
 }
 

package/src/services/electron/settings.ts

@@ -1,50 +1,48 @@
-import {
-  NetworkProxySettings,
-  ShortcutUpdateResult,
-  dispatch,
-} from '@lobechat/electron-client-ipc';
+import { NetworkProxySettings, ShortcutUpdateResult } from '@lobechat/electron-client-ipc';
+
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 class DesktopSettingsService {
   /**
    * Get proxy settings
    */
   getProxySettings = async () => {
-    return dispatch('getProxySettings');
+    return ensureElectronIpc().networkProxy.getDesktopSettings();
   };
 
   /**
    * Set proxy settings
    */
   setSettings = async (data: Partial<NetworkProxySettings>) => {
-    return dispatch('setProxySettings', data);
+    return ensureElectronIpc().networkProxy.setProxySettings(data);
   };
 
   /**
    * Get desktop hotkey configuration
    */
   getDesktopHotkeys = async () => {
-    return dispatch('getShortcutsConfig');
+    return ensureElectronIpc().shortcut.getShortcutsConfig();
   };
 
   /**
    * Update desktop hotkey configuration
    */
   updateDesktopHotkey = async (id: string, accelerator: string): Promise<ShortcutUpdateResult> => {
-    return dispatch('updateShortcutConfig', { accelerator, id });
+    return ensureElectronIpc().shortcut.updateShortcutConfig({ accelerator, id });
   };
 
   /**
    * Test proxy connection
    */
   testProxyConnection = async (url: string) => {
-    return dispatch('testProxyConnection', url);
+    return ensureElectronIpc().networkProxy.testProxyConnection(url);
   };
 
   /**
    * Test specified proxy configuration
    */
   testProxyConfig = async (config: NetworkProxySettings, testUrl?: string) => {
-    return dispatch('testProxyConfig', { config, testUrl });
+    return ensureElectronIpc().networkProxy.testProxyConfig({ config, testUrl });
   };
 }
 

package/src/services/electron/system.ts

@@ -1,4 +1,6 @@
-import { ElectronAppState, dispatch } from '@lobechat/electron-client-ipc';
+import { ElectronAppState } from '@lobechat/electron-client-ipc';
+
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 /**
  * Service class for interacting with Electron's system-level information and actions.
@@ -11,23 +13,23 @@ class ElectronSystemService {
    */
   async getAppState(): Promise<ElectronAppState> {
     // Calls the underlying IPC function to get data from the main process
-    return dispatch('getDesktopAppState');
+    return ensureElectronIpc().system.getAppState();
   }
 
   async closeWindow(): Promise<void> {
-    return dispatch('closeWindow');
+    return ensureElectronIpc().windows.closeWindow();
   }
 
   async maximizeWindow(): Promise<void> {
-    return dispatch('maximizeWindow');
+    return ensureElectronIpc().windows.maximizeWindow();
   }
 
   async minimizeWindow(): Promise<void> {
-    return dispatch('minimizeWindow');
+    return ensureElectronIpc().windows.minimizeWindow();
   }
 
   showContextMenu = async (type: string, data?: any) => {
-    return dispatch('showContextMenu', { data, type });
+    return ensureElectronIpc().menu.showContextMenu({ data, type });
   };
 }
 

package/src/store/chat/slices/plugin/actions/pluginTypes.ts

@@ -101,7 +101,7 @@ export const pluginTypes: StateCreator<
 
     let data: MCPToolCallResult | undefined;
 
-    // Get message to extract sessionId/topicId
+    // Get message to extract agentId/topicId
     const message = dbMessageSelectors.getDbMessageById(id)(get());
 
     // Get abort controller from operation

package/src/store/global/actions/general.ts

@@ -39,11 +39,10 @@ export const generalActionSlice: StateCreator<
     if (!isDesktop) return;
 
     try {
-      const { dispatch } = await import('@lobechat/electron-client-ipc');
-
+      const { ensureElectronIpc } = await import('@/utils/electron/ipc');
       const url = `/chat?session=${sessionId}&mode=single`;
 
-      const result = await dispatch('createMultiInstanceWindow', {
+      const result = await ensureElectronIpc().windows.createMultiInstanceWindow({
         path: url,
         templateId: 'chatSingle',
         uniqueId: `chat_${sessionId}`,
@@ -61,11 +60,10 @@ export const generalActionSlice: StateCreator<
     if (!isDesktop) return;
 
     try {
-      const { dispatch } = await import('@lobechat/electron-client-ipc');
-
+      const { ensureElectronIpc } = await import('@/utils/electron/ipc');
       const url = `/chat?session=${sessionId}&topic=${topicId}&mode=single`;
 
-      const result = await dispatch('createMultiInstanceWindow', {
+      const result = await ensureElectronIpc().windows.createMultiInstanceWindow({
         path: url,
         templateId: 'chatSingle',
         uniqueId: `chat_${sessionId}_${topicId}`,
@@ -87,9 +85,9 @@ export const generalActionSlice: StateCreator<
     if (isDesktop && !skipBroadcast) {
       (async () => {
         try {
-          const { dispatch } = await import('@lobechat/electron-client-ipc');
+          const { ensureElectronIpc } = await import('@/utils/electron/ipc');
 
-          await dispatch('updateLocale', locale);
+          await ensureElectronIpc().system.updateLocale(locale);
         } catch (error) {
           console.error('Failed to update locale in main process:', error);
         }
@@ -104,8 +102,8 @@ export const generalActionSlice: StateCreator<
     if (isDesktop && !skipBroadcast) {
       (async () => {
         try {
-          const { dispatch } = await import('@lobechat/electron-client-ipc');
-          await dispatch('updateThemeMode', themeMode);
+          const { ensureElectronIpc } = await import('@/utils/electron/ipc');
+          await ensureElectronIpc().system.updateThemeModeHandler(themeMode);
         } catch (error) {
           console.error('Failed to update theme in main process:', error);
         }

package/src/utils/electron/desktopRemoteRPCFetch.ts

@@ -1,10 +1,11 @@
 import { isDesktop } from '@lobechat/const';
-import { ProxyTRPCRequestParams, dispatch, streamInvoke } from '@lobechat/electron-client-ipc';
+import { ProxyTRPCRequestParams, streamInvoke } from '@lobechat/electron-client-ipc';
 import { getRequestBody, headersToRecord } from '@lobechat/fetch-sse';
 import debug from 'debug';
 
 import { getElectronStoreState } from '@/store/electron';
 import { electronSyncSelectors } from '@/store/electron/selectors';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
 
 const log = debug('utils:desktopRemoteRPCFetch');
 
@@ -30,7 +31,7 @@ export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) =
         urlPath,
       };
 
-      const ipcResult = await dispatch('proxyTRPCRequest', params);
+      const ipcResult = await ensureElectronIpc().remoteServerSync.proxyTRPCRequest(params);
 
       log(`Received ${url} IPC proxy response:`, { status: ipcResult.status });
       const response = new Response(ipcResult.body, {

package/src/utils/electron/ipc.ts

@@ -0,0 +1,12 @@
+import { getElectronIpc } from '@lobechat/electron-client-ipc';
+import type { DesktopIpcServices } from '@lobehub/desktop-ipc-typings';
+
+export const ensureElectronIpc = (): DesktopIpcServices => {
+  const ipc = getElectronIpc();
+  if (!ipc) {
+    throw new Error(
+      'electronAPI.invoke not found. Ensure the preload exposes invoke via window.electronAPI.invoke',
+    );
+  }
+  return ipc;
+};

package/tsconfig.json

@@ -47,5 +47,10 @@
     ".next/types/**/*.ts",
     "next-env.d.ts",
     ".next/dev/types/**/*.ts"
+  ],
+  "references": [
+    {
+      "path": "./apps/desktop"
+    }
   ]
 }

package/apps/desktop/src/main/types/ipcClientEvent.ts

@@ -1,3 +0,0 @@
-export interface IpcClientEventSender {
-  identifier: string;
-}

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

@@ -1,41 +0,0 @@
-import { DispatchInvoke, type ProxyTRPCRequestParams } from './types';
-
-interface StreamerCallbacks {
-  onData: (chunk: Uint8Array) => void;
-  onEnd: () => void;
-  onError: (error: Error) => void;
-  onResponse: (response: {
-    headers: Record<string, string>;
-    status: number;
-    statusText: string;
-  }) => void;
-}
-
-interface IElectronAPI {
-  invoke: DispatchInvoke;
-  onStreamInvoke: (params: ProxyTRPCRequestParams, callbacks: StreamerCallbacks) => () => void;
-}
-
-declare global {
-  interface Window {
-    electronAPI: IElectronAPI;
-  }
-}
-
-/**
- * client 端请求 main 端 event 数据的方法
- */
-export const dispatch: DispatchInvoke = async (event, ...data) => {
-  if (!window.electronAPI || !window.electronAPI.invoke)
-    throw new Error(`electronAPI.invoke not found. Please expose \`ipcRenderer.invoke\` to \`window.electronAPI.invoke\` in the preload:
-
-import { contextBridge, ipcRenderer } from 'electron';
-
-const invoke = async (event, ...data) =>
-  ipcRenderer.invoke(event, ...data);
-
-contextBridge.exposeInMainWorld('electronAPI', { invoke });
-`);
-
-  return window.electronAPI.invoke(event, ...data);
-};