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

package/apps/desktop/src/main/controllers/index.ts

@@ -1,34 +1,7 @@
-import type { ClientDispatchEvents } from '@lobechat/electron-client-ipc';
-import type { ServerDispatchEvents } from '@lobechat/electron-server-ipc';
-
 import type { App } from '@/core/App';
 import { IoCContainer } from '@/core/infrastructure/IoCContainer';
 import { ShortcutActionType } from '@/shortcuts';
-
-const ipcDecorator =
-  (name: string, mode: 'client' | 'server') =>
-  (target: any, methodName: string, descriptor?: any) => {
-    const actions = IoCContainer.controllers.get(target.constructor) || [];
-    actions.push({
-      methodName,
-      mode,
-      name,
-    });
-    IoCContainer.controllers.set(target.constructor, actions);
-    return descriptor;
-  };
-
-/**
- * IPC client event decorator for controllers
- */
-export const ipcClientEvent = (method: keyof ClientDispatchEvents) =>
-  ipcDecorator(method, 'client');
-
-/**
- * IPC server event decorator for controllers
- */
-export const ipcServerEvent = (method: keyof ServerDispatchEvents) =>
-  ipcDecorator(method, 'server');
+import { IpcService } from '@/utils/ipc';
 
 const shortcutDecorator = (name: string) => (target: any, methodName: string, descriptor?: any) => {
   const actions = IoCContainer.shortcuts.get(target.constructor) || [];
@@ -68,10 +41,13 @@ interface IControllerModule {
   beforeAppReady?(): void;
 }
 
-export class ControllerModule implements IControllerModule {
+export class ControllerModule extends IpcService implements IControllerModule {
   constructor(public app: App) {
+    super();
     this.app = app;
   }
 }
 
 export type IControlModule = typeof ControllerModule;
+
+export { IpcMethod, IpcServerMethod } from '@/utils/ipc';

package/apps/desktop/src/main/controllers/registry.ts

@@ -0,0 +1,52 @@
+import type { CreateServicesResult, IpcServiceConstructor, MergeIpcService } from '@/utils/ipc';
+
+import AuthCtr from './AuthCtr';
+import BrowserWindowsCtr from './BrowserWindowsCtr';
+import DevtoolsCtr from './DevtoolsCtr';
+import LocalFileCtr from './LocalFileCtr';
+import McpInstallCtr from './McpInstallCtr';
+import MenuController from './MenuCtr';
+import NetworkProxyCtr from './NetworkProxyCtr';
+import NotificationCtr from './NotificationCtr';
+import RemoteServerConfigCtr from './RemoteServerConfigCtr';
+import RemoteServerSyncCtr from './RemoteServerSyncCtr';
+import ShellCommandCtr from './ShellCommandCtr';
+import ShortcutController from './ShortcutCtr';
+import SystemController from './SystemCtr';
+import SystemServerCtr from './SystemServerCtr';
+import TrayMenuCtr from './TrayMenuCtr';
+import UpdaterCtr from './UpdaterCtr';
+import UploadFileCtr from './UploadFileCtr';
+import UploadFileServerCtr from './UploadFileServerCtr';
+
+export const controllerIpcConstructors = [
+  AuthCtr,
+  BrowserWindowsCtr,
+  DevtoolsCtr,
+  LocalFileCtr,
+  McpInstallCtr,
+  MenuController,
+  NetworkProxyCtr,
+  NotificationCtr,
+  RemoteServerConfigCtr,
+  RemoteServerSyncCtr,
+  ShellCommandCtr,
+  ShortcutController,
+  SystemController,
+  TrayMenuCtr,
+  UpdaterCtr,
+  UploadFileCtr,
+] as const satisfies readonly IpcServiceConstructor[];
+
+type DesktopControllerIpcConstructors = typeof controllerIpcConstructors;
+type DesktopControllerServices = CreateServicesResult<DesktopControllerIpcConstructors>;
+export type DesktopIpcServices = MergeIpcService<DesktopControllerServices>;
+
+export const controllerServerIpcConstructors = [
+  SystemServerCtr,
+  UploadFileServerCtr,
+] as const satisfies readonly IpcServiceConstructor[];
+
+type DesktopControllerServerConstructors = typeof controllerServerIpcConstructors;
+type DesktopServerControllerServices = CreateServicesResult<DesktopControllerServerConstructors>;
+export type DesktopServerIpcServices = MergeIpcService<DesktopServerControllerServices>;

package/apps/desktop/src/main/core/App.ts

@@ -1,16 +1,16 @@
 import { ElectronIPCEventHandler, ElectronIPCServer } from '@lobechat/electron-server-ipc';
-import { Session, app, ipcMain, protocol } from 'electron';
+import { Session, app, protocol } from 'electron';
 import { macOS, windows } from 'electron-is';
 import { pathExistsSync, remove } from 'fs-extra';
 import os from 'node:os';
 import { join } from 'node:path';
 
 import { name } from '@/../../package.json';
-import { buildDir, LOCAL_DATABASE_DIR, nextStandaloneDir } from '@/const/dir';
+import { LOCAL_DATABASE_DIR, buildDir, nextStandaloneDir } from '@/const/dir';
 import { isDev } from '@/const/env';
 import { IControlModule } from '@/controllers';
 import { IServiceModule } from '@/services';
-import { IpcClientEventSender } from '@/types/ipcClientEvent';
+import { getServerMethodMetadata } from '@/utils/ipc';
 import { createLogger } from '@/utils/logger';
 import { CustomRequestHandler, createHandler } from '@/utils/next-electron-rsc';
 
@@ -81,7 +81,7 @@ export class App {
 
     // load controllers
     const controllers: IControlModule[] = importAll(
-      (import.meta as any).glob('@/controllers/*Ctr.ts', { eager: true }),
+      import.meta.glob('@/controllers/*Ctr.ts', { eager: true }),
     );
 
     logger.debug(`Loading ${controllers.length} controllers`);
@@ -89,13 +89,13 @@ export class App {
 
     // load services
     const services: IServiceModule[] = importAll(
-      (import.meta as any).glob('@/services/*Srv.ts', { eager: true }),
+      import.meta.glob('@/services/*Srv.ts', { eager: true }),
     );
 
     logger.debug(`Loading ${services.length} services`);
     services.forEach((service) => this.addService(service));
 
-    this.initializeIPCEvents();
+    this.initializeServerIpcEvents();
 
     this.i18n = new I18nManager(this);
     this.browserManager = new BrowserManager(this);
@@ -268,10 +268,6 @@ export class App {
   private services = new Map<Class<any>, any>();
 
   private ipcServer: ElectronIPCServer;
-  /**
-   * events dispatched from webview layer
-   */
-  private ipcClientEventMap: IPCEventMap = new Map();
   private ipcServerEventMap: IPCEventMap = new Map();
   shortcutMethodMap: ShortcutMethodMap = new Map();
   protocolHandlerMap: ProtocolHandlerMap = new Map();
@@ -327,22 +323,13 @@ export class App {
     const controller = new ControllerClass(this);
     this.controllers.set(ControllerClass, controller);
 
-    IoCContainer.controllers.get(ControllerClass)?.forEach((event) => {
-      if (event.mode === 'client') {
-        // Store all objects from event decorator in ipcClientEventMap
-        this.ipcClientEventMap.set(event.name, {
-          controller,
-          methodName: event.methodName,
-        });
-      }
-
-      if (event.mode === 'server') {
-        // Store all objects from event decorator in ipcServerEventMap
-        this.ipcServerEventMap.set(event.name, {
-          controller,
-          methodName: event.methodName,
-        });
-      }
+    const serverMethods = getServerMethodMetadata(ControllerClass);
+    serverMethods?.forEach((methodName, propertyKey) => {
+      const channel = `${ControllerClass.groupName}.${methodName}`;
+      this.ipcServerEventMap.set(channel, {
+        controller,
+        methodName: propertyKey,
+      });
     });
 
     IoCContainer.shortcuts.get(ControllerClass)?.forEach((shortcut) => {
@@ -427,27 +414,8 @@ export class App {
     }
   }
 
-  private initializeIPCEvents() {
-    logger.debug('Initializing IPC events');
-    // Register batch controller client events for render side consumption
-    this.ipcClientEventMap.forEach((eventInfo, key) => {
-      const { controller, methodName } = eventInfo;
-
-      ipcMain.handle(key, async (e, data) => {
-        // 从 WebContents 获取对应的 BrowserWindow id
-        const senderIdentifier = this.browserManager.getIdentifierByWebContents(e.sender);
-        try {
-          return await controller[methodName](data, {
-            identifier: senderIdentifier,
-          } as IpcClientEventSender);
-        } catch (error) {
-          logger.error(`Error handling IPC event ${key}:`, error);
-          return { error: error.message };
-        }
-      });
-    });
-
-    // Batch register server events from controllers for next server consumption
+  private initializeServerIpcEvents() {
+    logger.debug('Initializing IPC server events');
     const ipcServerEvents = {} as ElectronIPCEventHandler;
 
     this.ipcServerEventMap.forEach((eventInfo, key) => {

package/apps/desktop/src/main/core/__tests__/App.test.ts

@@ -5,6 +5,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { LOCAL_DATABASE_DIR } from '@/const/dir';
 
+// Import after mocks are set up
+import { App } from '../App';
+
 // Mock electron modules
 vi.mock('electron', () => ({
   app: {
@@ -24,6 +27,7 @@ vi.mock('electron', () => ({
   },
   ipcMain: {
     handle: vi.fn(),
+    on: vi.fn(),
   },
   nativeTheme: {
     on: vi.fn(),
@@ -166,9 +170,6 @@ vi.mock('@/utils/next-electron-rsc', () => ({
 vi.mock('../../controllers/*Ctr.ts', () => ({}));
 vi.mock('../../services/*Srv.ts', () => ({}));
 
-// Import after mocks are set up
-import { App } from '../App';
-
 describe('App - Database Lock Cleanup', () => {
   let appInstance: App;
   let mockLockPath: string;
@@ -177,7 +178,7 @@ describe('App - Database Lock Cleanup', () => {
     vi.clearAllMocks();
 
     // Mock glob imports to return empty arrays
-    (import.meta as any).glob = vi.fn(() => ({}));
+    import.meta.glob = vi.fn(() => ({}));
 
     mockLockPath = join('/mock/storage/path', LOCAL_DATABASE_DIR) + '.lock';
   });

package/apps/desktop/src/main/core/infrastructure/IoCContainer.ts

@@ -2,11 +2,6 @@
  * 存储应用中需要用装饰器的类
  */
 export class IoCContainer {
-  static controllers: WeakMap<
-    any,
-    { methodName: string; mode: 'client' | 'server'; name: string }[]
-  > = new WeakMap();
-
   static shortcuts: WeakMap<any, { methodName: string; name: string }[]> = new WeakMap();
 
   static protocolHandlers: WeakMap<any, { action: string; methodName: string; urlType: string }[]> =

package/apps/desktop/src/main/core/infrastructure/__tests__/IoCContainer.test.ts

@@ -13,52 +13,6 @@ describe('IoCContainer', () => {
     // For each test, use fresh class instances
   });
 
-  describe('controllers WeakMap', () => {
-    it('should store controller metadata', () => {
-      const metadata = [{ methodName: 'handleMessage', mode: 'client' as const, name: 'message' }];
-
-      IoCContainer.controllers.set(TestController, metadata);
-
-      expect(IoCContainer.controllers.get(TestController)).toEqual(metadata);
-    });
-
-    it('should allow multiple controllers', () => {
-      const metadata1 = [{ methodName: 'method1', mode: 'client' as const, name: 'action1' }];
-      const metadata2 = [{ methodName: 'method2', mode: 'server' as const, name: 'action2' }];
-
-      IoCContainer.controllers.set(TestController, metadata1);
-      IoCContainer.controllers.set(AnotherController, metadata2);
-
-      expect(IoCContainer.controllers.get(TestController)).toEqual(metadata1);
-      expect(IoCContainer.controllers.get(AnotherController)).toEqual(metadata2);
-    });
-
-    it('should allow overwriting controller metadata', () => {
-      const oldMetadata = [{ methodName: 'oldMethod', mode: 'client' as const, name: 'old' }];
-      const newMetadata = [{ methodName: 'newMethod', mode: 'server' as const, name: 'new' }];
-
-      IoCContainer.controllers.set(TestController, oldMetadata);
-      IoCContainer.controllers.set(TestController, newMetadata);
-
-      expect(IoCContainer.controllers.get(TestController)).toEqual(newMetadata);
-    });
-
-    it('should support multiple methods per controller', () => {
-      const metadata = [
-        { methodName: 'method1', mode: 'client' as const, name: 'action1' },
-        { methodName: 'method2', mode: 'server' as const, name: 'action2' },
-        { methodName: 'method3', mode: 'client' as const, name: 'action3' },
-      ];
-
-      IoCContainer.controllers.set(TestController, metadata);
-
-      const stored = IoCContainer.controllers.get(TestController);
-      expect(stored).toHaveLength(3);
-      expect(stored?.[0].mode).toBe('client');
-      expect(stored?.[1].mode).toBe('server');
-    });
-  });
-
   describe('shortcuts WeakMap', () => {
     it('should store shortcut metadata', () => {
       const metadata = [{ methodName: 'toggleDarkMode', name: 'CmdOrCtrl+Shift+D' }];
@@ -141,10 +95,6 @@ describe('IoCContainer', () => {
   });
 
   describe('static properties', () => {
-    it('should have controllers as a WeakMap', () => {
-      expect(IoCContainer.controllers).toBeInstanceOf(WeakMap);
-    });
-
     it('should have shortcuts as a WeakMap', () => {
       expect(IoCContainer.shortcuts).toBeInstanceOf(WeakMap);
     });

package/apps/desktop/src/main/exports.d.ts

@@ -0,0 +1,8 @@
+import type { DesktopIpcServices } from './controllers/registry';
+
+declare module '@lobechat/electron-client-ipc' {
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface DesktopIpcServicesMap extends DesktopIpcServices {}
+}
+
+export { type DesktopIpcServices, type DesktopServerIpcServices } from './controllers/registry';

package/apps/desktop/src/main/exports.ts

@@ -0,0 +1,2 @@
+// Export types for renderer/server to use
+export type { DesktopIpcServices, DesktopServerIpcServices } from './controllers/registry';

package/apps/desktop/src/main/global.d.ts

@@ -0,0 +1,3 @@
+import 'vite/client';
+
+export {};

package/apps/desktop/src/main/modules/fileSearch/__tests__/macOS.integration.test.ts

@@ -17,6 +17,12 @@ const repoRoot = path.resolve(__dirname, '../../../../..');
 
 describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integration', () => {
   const searchService = new MacOSSearchServiceImpl();
+  const ensureResults = (results: unknown[], context: string) => {
+    if (results.length > 0) return true;
+    // eslint-disable-next-line no-console
+    console.warn(`⚠️  Spotlight returned 0 results for ${context} - indexing may be incomplete`);
+    return false;
+  };
 
   describe('checkSearchServiceStatus', () => {
     it('should verify Spotlight is available on macOS', async () => {
@@ -34,7 +40,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'package.json search')) return;
 
       // Should find at least one package.json
       const packageJson = results.find((r) => r.name === 'package.json');
@@ -49,7 +55,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         limit: 10,
         onlyIn: repoRoot,
       });
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'README search')) return;
 
       // Should contain markdown files
       const mdFile = results.find((r) => r.type === 'md');
@@ -64,7 +70,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'TypeScript file search')) return;
 
       // Should find the macOS.ts implementation file
       const macOSFile = results.find((r) => r.name.includes('macOS') && r.type === 'ts');
@@ -106,7 +112,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'test file search')) return;
 
       // Should find test files (can be in __tests__ directory or co-located with source files)
       const testFile = results.find((r) => r.name.endsWith('.test.ts'));
@@ -161,6 +167,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
+      if (!ensureResults(results, 'TypeScript identification')) return;
       const tsFile = results.find((r) => r.name === 'LocalFileCtr.ts');
       if (tsFile) {
         expect(tsFile.type).toBe('ts');
@@ -176,6 +183,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
+      if (!ensureResults(results, 'JSON identification')) return;
       const jsonFile = results.find((r) => r.name.includes('tsconfig') && r.type === 'json');
       if (jsonFile) {
         expect(jsonFile.type).toBe('json');
@@ -191,6 +199,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
+      if (!ensureResults(results, 'directory identification')) return;
       const testDir = results.find((r) => r.name === '__tests__' && r.isDirectory);
       if (testDir) {
         expect(testDir.isDirectory).toBe(true);
@@ -221,7 +230,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'file metadata read')) return;
 
       const file = results[0];
 
@@ -279,7 +288,7 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
         onlyIn: repoRoot,
       });
 
-      expect(results.length).toBeGreaterThan(0);
+      if (!ensureResults(results, 'fuzzy search accuracy')) return;
 
       // Should find LocalFileCtr.ts or similar files
       const found = results.some(
@@ -319,8 +328,8 @@ describe.skipIf(process.platform !== 'darwin')('MacOSSearchServiceImpl Integrati
       });
 
       // Both searches should find similar files
-      expect(lowerResults.length).toBeGreaterThan(0);
-      expect(upperResults.length).toBeGreaterThan(0);
+      if (!ensureResults(lowerResults, 'case-insensitive search (lower)')) return;
+      if (!ensureResults(upperResults, 'case-insensitive search (upper)')) return;
     });
   });
 

package/apps/desktop/src/main/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@lobehub/desktop-ipc-typings",
+  "version": "1.0.0",
+  "private": true,
+  "main": "./exports.d.ts",
+  "types": "./exports.d.ts",
+  "exports": {
+    ".": "./exports.d.ts"
+  }
+}

package/apps/desktop/src/main/services/fileSrv.ts

@@ -37,7 +37,7 @@ interface UploadFileParams {
   type: string;
 }
 
-interface FileMetadata {
+export interface FileMetadata {
   date: string;
   dirname: string;
   filename: string;

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

@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { IpcContext } from '../base';
+import {
+  IpcMethod,
+  IpcServerMethod,
+  IpcService,
+  getIpcContext,
+  getServerMethodMetadata,
+} from '../base';
+
+const { ipcMainHandleMock } = vi.hoisted(() => ({
+  ipcMainHandleMock: vi.fn(),
+}));
+
+vi.mock('electron', () => ({
+  ipcMain: {
+    handle: ipcMainHandleMock,
+  },
+}));
+
+describe('ipc service base', () => {
+  beforeEach(() => {
+    ipcMainHandleMock.mockClear();
+  });
+
+  it('registers handlers and forwards payload/context correctly', async () => {
+    class TestService extends IpcService {
+      static readonly groupName = 'test';
+      public lastCall: { payload: string | undefined; context?: IpcContext } | null = null;
+
+      @IpcMethod()
+      ping(payload?: string) {
+        this.lastCall = { context: getIpcContext(), payload };
+        return 'pong';
+      }
+    }
+
+    const service = new TestService();
+
+    expect(service).toBeTruthy();
+    expect(ipcMainHandleMock).toHaveBeenCalledWith('test.ping', expect.any(Function));
+
+    const handler = ipcMainHandleMock.mock.calls[0][1];
+    const fakeSender = { id: 1 } as any;
+    const fakeEvent = { sender: fakeSender } as any;
+
+    const result = await handler(fakeEvent, 'hello');
+
+    expect(result).toBe('pong');
+    expect(service.lastCall).toEqual({
+      context: { event: fakeEvent, sender: fakeSender },
+      payload: 'hello',
+    });
+  });
+
+  it('allows direct method invocation without IPC context', () => {
+    class DirectCallService extends IpcService {
+      static readonly groupName = 'direct';
+      public invokedWith: string | null = null;
+
+      @IpcMethod()
+      run(payload: string) {
+        this.invokedWith = payload;
+        return payload.toUpperCase();
+      }
+    }
+
+    const service = new DirectCallService();
+    const result = service.run('test');
+
+    expect(result).toBe('TEST');
+    expect(service.invokedWith).toBe('test');
+    expect(ipcMainHandleMock).toHaveBeenCalledWith('direct.run', expect.any(Function));
+  });
+
+  it('collects server method metadata for decorators', () => {
+    class ServerService extends IpcService {
+      static readonly groupName = 'server';
+
+      @IpcServerMethod()
+      fetch(_: string) {
+        return 'ok';
+      }
+    }
+
+    const metadata = getServerMethodMetadata(ServerService);
+    expect(metadata).toBeDefined();
+    expect(metadata?.get('fetch')).toBe('fetch');
+  });
+});