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

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;
+};

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

@@ -34,7 +34,13 @@ export const streamInvoke = async (input: RequestInfo | URL, init?: RequestInit)
       },
     });
 
-    const cleanup = window.electronAPI.onStreamInvoke(params, {
+    const electronAPI = window.electronAPI;
+    if (!electronAPI || !electronAPI.onStreamInvoke) {
+      reject(new Error('[streamInvoke] window.electronAPI.onStreamInvoke is not available'));
+      return;
+    }
+
+    const cleanup = electronAPI.onStreamInvoke(params, {
       onData: (chunk) => {
         if (streamController) streamController.enqueue(chunk);
       },

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

@@ -1,10 +1 @@
-import type {
-  ClientDispatchEventKey,
-  ClientDispatchEvents,
-  ClientEventReturnType,
-} from '../events';
-
-export type DispatchInvoke = <T extends ClientDispatchEventKey>(
-  event: T,
-  ...data: Parameters<ClientDispatchEvents[T]>
-) => Promise<ClientEventReturnType<T>>;
+export type DispatchInvoke = <T = unknown>(event: string, ...data: any[]) => Promise<T>;

package/packages/electron-client-ipc/vitest.config.mts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+    },
+    environment: 'node',
+  },
+});

package/packages/electron-server-ipc/src/ipcClient.ts

@@ -5,7 +5,6 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { SOCK_FILE, SOCK_INFO_FILE, WINDOW_PIPE_FILE } from './const';
-import { ServerDispatchEventKey } from './events';
 
 const log = debug('electron-server-ipc:client');
 
@@ -178,7 +177,7 @@ export class ElectronIpcClient {
   }
 
   // Send request to Electron IPC server
-  public async sendRequest<T>(method: ServerDispatchEventKey, params: any = {}): Promise<T> {
+  public async sendRequest<T>(method: string, params: any = {}): Promise<T> {
     if (!this.socketPath) {
       console.error('Cannot send request: Electron IPC connection not available');
       throw new Error('Electron IPC connection not available');

package/packages/electron-server-ipc/src/ipcServer.ts

@@ -5,7 +5,6 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { SOCK_FILE, SOCK_INFO_FILE, WINDOW_PIPE_FILE } from './const';
-import { ServerDispatchEventKey } from './events';
 import { ElectronIPCEventHandler } from './types';
 
 const log = debug('electron-server-ipc:server');
@@ -107,7 +106,7 @@ export class ElectronIPCServer {
     log('Handling request: %s (ID: %s)', method, id);
 
     // Execute corresponding operation based on request method
-    const eventHandler = this.eventHandler[method as ServerDispatchEventKey];
+    const eventHandler = this.eventHandler[method];
     if (!eventHandler) {
       console.error('No handler found for method: %s', method);
       return;

package/packages/electron-server-ipc/src/types/index.ts

@@ -1,14 +1,10 @@
 import net from 'node:net';
 
-import { ServerDispatchEventKey } from '../events';
-
 export type IPCEventMethod = (
   params: any,
   context: { id: string; method: string; socket: net.Socket },
 ) => Promise<any>;
 
-export type ElectronIPCEventHandler = {
-  [key in ServerDispatchEventKey]: IPCEventMethod;
-};
+export type ElectronIPCEventHandler = Record<string, IPCEventMethod>;
 
 export * from './file';

package/pnpm-workspace.yaml

@@ -2,4 +2,4 @@ packages:
   - 'packages/**'
   - '.'
   - 'e2e'
-  - '!apps/**'
+  - 'apps/desktop/src/main'

package/scripts/i18nWorkflow/const.ts

@@ -1,7 +1,7 @@
 import { readdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-import i18nConfig from '../../.i18nrc';
+import i18nConfig from './i18nConfig';
 
 export const root = resolve(__dirname, '../..');
 export const localesDir = resolve(root, i18nConfig.output);
@@ -15,4 +15,4 @@ export const outputLocaleJsonFilepath = (locale: string, file: string) =>
   resolve(localesDir, locale, file);
 export const srcDefaultLocales = resolve(root, srcLocalesDir, 'default');
 
-export { default as i18nConfig } from '../../.i18nrc';
+export { default as i18nConfig } from './i18nConfig';

package/scripts/i18nWorkflow/i18nConfig.ts

@@ -0,0 +1,7 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+const config = require('../../.i18nrc');
+
+export default config;

package/scripts/i18nWorkflow/utils.ts

@@ -3,7 +3,7 @@ import { colors } from 'consola/utils';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import prettier from "@prettier/sync";
-import i18nConfig from '../../.i18nrc';
+import i18nConfig from './i18nConfig';
 
 let prettierOptions = prettier.resolveConfig(
   resolve(__dirname, '../../.prettierrc.js')

package/src/app/[variants]/(main)/discover/(detail)/provider/features/Sidebar/ActionButton/ProviderConfig.tsx

@@ -30,8 +30,8 @@ const ProviderConfig = memo(() => {
     const tab = 'provider';
 
     if (isDesktop) {
-      const { dispatch } = await import('@lobechat/electron-client-ipc');
-      await dispatch('openSettingsWindow', {
+      const { ensureElectronIpc } = await import('@/utils/electron/ipc');
+      await ensureElectronIpc().windows.openSettingsWindow({
         searchParams,
         tab,
       });

package/src/locales/default/setting.ts

@@ -806,6 +806,7 @@ export default {
       noEnabled: '暂无启用插件',
       store: '插件商店',
     },
+
     tabs: {
       all: '全部',
       installed: '已启用',

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 });
   };
 }