@lobehub/chat 1.82.10 → 1.83.0

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

@@ -0,0 +1,93 @@
+import { ElectronAppState } from '@lobechat/electron-client-ipc';
+import { app, systemPreferences } from 'electron';
+import { macOS } from 'electron-is';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+
+import { DB_SCHEMA_HASH_FILENAME, LOCAL_DATABASE_DIR, userDataDir } from '@/const/dir';
+
+import { ControllerModule, ipcClientEvent, ipcServerEvent } from './index';
+
+export default class SystemController extends ControllerModule {
+  /**
+   * Handles the 'getDesktopAppState' IPC request.
+   * Gathers essential application and system information.
+   */
+  @ipcClientEvent('getDesktopAppState')
+  async getAppState(): Promise<ElectronAppState> {
+    const platform = process.platform;
+    const arch = process.arch;
+
+    return {
+      // System Info
+      arch,
+      isLinux: platform === 'linux',
+      isMac: platform === 'darwin',
+      isWindows: platform === 'win32',
+      platform: platform as 'darwin' | 'win32' | 'linux',
+      userPath: {
+        // User Paths (ensure keys match UserPathData / DesktopAppState interface)
+        desktop: app.getPath('desktop'),
+        documents: app.getPath('documents'),
+        downloads: app.getPath('downloads'),
+        home: app.getPath('home'),
+        music: app.getPath('music'),
+        pictures: app.getPath('pictures'),
+        userData: app.getPath('userData'),
+        videos: app.getPath('videos'),
+      },
+    };
+  }
+
+  /**
+   * 检查可用性
+   */
+  @ipcClientEvent('checkSystemAccessibility')
+  checkAccessibilityForMacOS() {
+    if (!macOS()) return;
+    return systemPreferences.isTrustedAccessibilityClient(true);
+  }
+
+  /**
+   * 更新应用语言设置
+   */
+  @ipcClientEvent('updateLocale')
+  async updateLocale(locale: string) {
+    // 保存语言设置
+    this.app.storeManager.set('locale', locale);
+
+    // 更新i18n实例的语言
+    await this.app.i18n.changeLanguage(locale === 'auto' ? app.getLocale() : locale);
+
+    return { success: true };
+  }
+
+  @ipcServerEvent('getDatabasePath')
+  async getDatabasePath() {
+    return join(this.app.appStoragePath, LOCAL_DATABASE_DIR);
+  }
+
+  @ipcServerEvent('getDatabaseSchemaHash')
+  async getDatabaseSchemaHash() {
+    try {
+      return readFileSync(this.DB_SCHEMA_HASH_PATH, 'utf8');
+    } catch {
+      return undefined;
+    }
+  }
+
+  @ipcServerEvent('getUserDataPath')
+  async getUserDataPath() {
+    return userDataDir;
+  }
+
+  @ipcServerEvent('setDatabaseSchemaHash')
+  async setDatabaseSchemaHash(hash: string) {
+    writeFileSync(this.DB_SCHEMA_HASH_PATH, hash, 'utf8');
+  }
+
+  private get DB_SCHEMA_HASH_PATH() {
+    return join(this.app.appStoragePath, DB_SCHEMA_HASH_FILENAME);
+  }
+}

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

@@ -0,0 +1,43 @@
+import { createLogger } from '@/utils/logger';
+
+import { ControllerModule, ipcClientEvent } from './index';
+
+const logger = createLogger('controllers:UpdaterCtr');
+
+export default class UpdaterCtr extends ControllerModule {
+  /**
+   * 检查更新
+   */
+  @ipcClientEvent('checkUpdate')
+  async checkForUpdates() {
+    logger.info('Check for updates requested');
+    await this.app.updaterManager.checkForUpdates();
+  }
+
+  /**
+   * 下载更新
+   */
+  @ipcClientEvent('downloadUpdate')
+  async downloadUpdate() {
+    logger.info('Download update requested');
+    await this.app.updaterManager.downloadUpdate();
+  }
+
+  /**
+   * 关闭应用并安装更新
+   */
+  @ipcClientEvent('installNow')
+  quitAndInstallUpdate() {
+    logger.info('Quit and install update requested');
+    this.app.updaterManager.installNow();
+  }
+
+  /**
+   * 下次启动时安装更新
+   */
+  @ipcClientEvent('installLater')
+  installLater() {
+    logger.info('Install later requested');
+    this.app.updaterManager.installLater();
+  }
+}

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

@@ -0,0 +1,34 @@
+import FileService from '@/services/fileSrv';
+
+import { ControllerModule, ipcClientEvent, ipcServerEvent } from './index';
+
+interface UploadFileParams {
+  content: ArrayBuffer;
+  filename: string;
+  hash: string;
+  path: string;
+  type: string;
+}
+
+export default class UploadFileCtr extends ControllerModule {
+  private get fileService() {
+    return this.app.getService(FileService);
+  }
+
+  @ipcClientEvent('createFile')
+  async uploadFile(params: UploadFileParams) {
+    return this.fileService.uploadFile(params);
+  }
+
+  // ======== server event
+
+  @ipcServerEvent('getStaticFilePath')
+  async getFileUrlById(id: string) {
+    return this.fileService.getFilePath(id);
+  }
+
+  @ipcServerEvent('deleteFiles')
+  async deleteFiles(paths: string[]) {
+    return this.fileService.deleteFiles(paths);
+  }
+}

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

@@ -0,0 +1,9 @@
+import { ControllerModule, ipcClientEvent } from './index';
+
+export default class DevtoolsCtr extends ControllerModule {
+  @ipcClientEvent('openDevtools')
+  async openDevtools() {
+    const devtoolsBrowser = this.app.browserManager.retrieveByIdentifier('devtools');
+    devtoolsBrowser.show();
+  }
+}

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

@@ -0,0 +1,58 @@
+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/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;
+  };
+
+/**
+ *  controller 用的 ipc client event 装饰器
+ */
+export const ipcClientEvent = (method: keyof ClientDispatchEvents) =>
+  ipcDecorator(method, 'client');
+
+/**
+ *  controller 用的 ipc server event 装饰器
+ */
+export const ipcServerEvent = (method: keyof ServerDispatchEvents) =>
+  ipcDecorator(method, 'server');
+
+const shortcutDecorator = (name: string) => (target: any, methodName: string, descriptor?: any) => {
+  const actions = IoCContainer.shortcuts.get(target.constructor) || [];
+  actions.push({ methodName, name });
+
+  IoCContainer.shortcuts.set(target.constructor, actions);
+
+  return descriptor;
+};
+
+/**
+ *  shortcut inject decorator
+ */
+export const shortcut = (method: ShortcutActionType) => shortcutDecorator(method);
+
+interface IControllerModule {
+  afterAppReady?(): void;
+  app: App;
+  beforeAppReady?(): void;
+}
+export class ControllerModule implements IControllerModule {
+  constructor(public app: App) {
+    this.app = app;
+  }
+}
+
+export type IControlModule = typeof ControllerModule;

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

@@ -0,0 +1,370 @@
+import { ElectronIPCEventHandler, ElectronIPCServer } from '@lobechat/electron-server-ipc';
+import { Session, app, ipcMain, protocol } from 'electron';
+import { macOS, windows } from 'electron-is';
+import { join } from 'node:path';
+
+import { name } from '@/../../package.json';
+import { buildDir, nextStandaloneDir } from '@/const/dir';
+import { isDev } from '@/const/env';
+import { IControlModule } from '@/controllers';
+import { IServiceModule } from '@/services';
+import { createLogger } from '@/utils/logger';
+import { CustomRequestHandler, createHandler } from '@/utils/next-electron-rsc';
+
+import BrowserManager from './BrowserManager';
+import { I18nManager } from './I18nManager';
+import { IoCContainer } from './IoCContainer';
+import MenuManager from './MenuManager';
+import { ShortcutManager } from './ShortcutManager';
+import { StoreManager } from './StoreManager';
+import { UpdaterManager } from './UpdaterManager';
+
+const logger = createLogger('core:App');
+
+export type IPCEventMap = Map<string, { controller: any; methodName: string }>;
+export type ShortcutMethodMap = Map<string, () => Promise<void>>;
+
+type Class<T> = new (...args: any[]) => T;
+
+const importAll = (r: any) => Object.values(r).map((v: any) => v.default);
+
+export class App {
+  nextServerUrl = 'http://localhost:3015';
+
+  browserManager: BrowserManager;
+  menuManager: MenuManager;
+  i18n: I18nManager;
+  storeManager: StoreManager;
+  updaterManager: UpdaterManager;
+  shortcutManager: ShortcutManager;
+
+  /**
+   * whether app is in quiting
+   */
+  isQuiting: boolean = false;
+
+  get appStoragePath() {
+    const storagePath = this.storeManager.get('storagePath');
+
+    if (!storagePath) {
+      throw new Error('Storage path not found in store');
+    }
+
+    return storagePath;
+  }
+
+  constructor() {
+    logger.info('----------------------------------------------');
+    logger.info('Starting LobeHub...');
+
+    logger.debug('Initializing App');
+    // Initialize store manager
+    this.storeManager = new StoreManager(this);
+
+    // load controllers
+    const controllers: IControlModule[] = importAll(
+      (import.meta as any).glob('@/controllers/*Ctr.ts', { eager: true }),
+    );
+
+    logger.debug(`Loading ${controllers.length} controllers`);
+    controllers.forEach((controller) => this.addController(controller));
+
+    // load services
+    const services: IServiceModule[] = importAll(
+      (import.meta as any).glob('@/services/*Srv.ts', { eager: true }),
+    );
+
+    logger.debug(`Loading ${services.length} services`);
+    services.forEach((service) => this.addService(service));
+
+    this.initializeIPCEvents();
+
+    this.i18n = new I18nManager(this);
+    this.browserManager = new BrowserManager(this);
+    this.menuManager = new MenuManager(this);
+    this.updaterManager = new UpdaterManager(this);
+    this.shortcutManager = new ShortcutManager(this);
+
+    // register the schema to interceptor url
+    // it should register before app ready
+    this.registerNextHandler();
+
+    // 统一处理 before-quit 事件
+    app.on('before-quit', this.handleBeforeQuit);
+
+    logger.info('App initialization completed');
+  }
+
+  bootstrap = async () => {
+    logger.info('Bootstrapping application');
+    // make single instance
+    const isSingle = app.requestSingleInstanceLock();
+    if (!isSingle) {
+      logger.info('Another instance is already running, exiting');
+      app.exit(0);
+    }
+
+    this.initDevBranding();
+
+    //  ==============
+    await this.ipcServer.start();
+    logger.debug('IPC server started');
+
+    // Initialize app
+    await this.makeAppReady();
+
+    // Initialize i18n. Note: app.getLocale() must be called after app.whenReady() to get the correct value
+    await this.i18n.init();
+    this.menuManager.initialize();
+
+    // Initialize global shortcuts: globalShortcut must be called after app.whenReady()
+    this.shortcutManager.initialize();
+
+    this.browserManager.initializeBrowsers();
+
+    // Initialize updater manager
+    await this.updaterManager.initialize();
+
+    // Set global application exit state
+    this.isQuiting = false;
+
+    app.on('window-all-closed', () => {
+      if (windows()) {
+        logger.info('All windows closed, quitting application (Windows)');
+        app.quit();
+      }
+    });
+
+    app.on('activate', this.onActivate);
+    logger.info('Application bootstrap completed');
+  };
+
+  getService<T>(serviceClass: Class<T>): T {
+    return this.services.get(serviceClass);
+  }
+
+  getController<T>(controllerClass: Class<T>): T {
+    return this.controllers.get(controllerClass);
+  }
+
+  private onActivate = () => {
+    logger.debug('Application activated');
+    this.browserManager.showMainWindow();
+  };
+
+  /**
+   * Call beforeAppReady method on all controllers before the application is ready
+   */
+  private makeAppReady = async () => {
+    logger.debug('Preparing application ready state');
+    this.controllers.forEach((controller) => {
+      if (typeof controller.beforeAppReady === 'function') {
+        try {
+          controller.beforeAppReady();
+        } catch (error) {
+          logger.error(`Error in controller.beforeAppReady:`, error);
+          console.error(`[App] Error in controller.beforeAppReady:`, error);
+        }
+      }
+    });
+
+    logger.debug('Waiting for app to be ready');
+    await app.whenReady();
+    logger.debug('Application ready');
+
+    this.controllers.forEach((controller) => {
+      if (typeof controller.afterAppReady === 'function') {
+        try {
+          controller.afterAppReady();
+        } catch (error) {
+          logger.error(`Error in controller.afterAppReady:`, error);
+          console.error(`[App] Error in controller.beforeAppReady:`, error);
+        }
+      }
+    });
+    logger.info('Application ready state completed');
+  };
+
+  // ============= helper ============= //
+
+  /**
+   * all controllers in app
+   */
+  private controllers = new Map<Class<any>, any>();
+  /**
+   * all services in 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();
+
+  /**
+   * use in next router interceptor in prod browser render
+   */
+  nextInterceptor: (params: { session: Session }) => () => void;
+
+  /**
+   * Collection of unregister functions for custom request handlers
+   */
+  private customHandlerUnregisterFns: Array<() => void> = [];
+
+  /**
+   * Function to register custom request handler
+   */
+  private registerCustomHandlerFn?: (handler: CustomRequestHandler) => () => void;
+
+  /**
+   * Register custom request handler
+   * @param handler Custom request handler function
+   * @returns Function to unregister the handler
+   */
+  registerRequestHandler = (handler: CustomRequestHandler): (() => void) => {
+    if (!this.registerCustomHandlerFn) {
+      logger.warn('Custom request handler registration is not available');
+      return () => {};
+    }
+
+    logger.debug('Registering custom request handler');
+    const unregisterFn = this.registerCustomHandlerFn(handler);
+    this.customHandlerUnregisterFns.push(unregisterFn);
+
+    return () => {
+      unregisterFn();
+      const index = this.customHandlerUnregisterFns.indexOf(unregisterFn);
+      if (index !== -1) {
+        this.customHandlerUnregisterFns.splice(index, 1);
+      }
+    };
+  };
+
+  /**
+   * Unregister all custom request handlers
+   */
+  unregisterAllRequestHandlers = () => {
+    this.customHandlerUnregisterFns.forEach((unregister) => unregister());
+    this.customHandlerUnregisterFns = [];
+  };
+
+  private addController = (ControllerClass: IControlModule) => {
+    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,
+        });
+      }
+    });
+
+    IoCContainer.shortcuts.get(ControllerClass)?.forEach((shortcut) => {
+      this.shortcutMethodMap.set(shortcut.name, async () => {
+        controller[shortcut.methodName]();
+      });
+    });
+  };
+
+  private addService = (ServiceClass: IServiceModule) => {
+    const service = new ServiceClass(this);
+    this.services.set(ServiceClass, service);
+  };
+
+  private initDevBranding = () => {
+    if (!isDev) return;
+
+    logger.debug('Setting up dev branding');
+    app.setName('lobehub-desktop-dev');
+    if (macOS()) {
+      app.dock!.setIcon(join(buildDir, 'icon-dev.png'));
+    }
+  };
+
+  private registerNextHandler() {
+    logger.debug('Registering Next.js handler');
+    const handler = createHandler({
+      debug: true,
+      localhostUrl: this.nextServerUrl,
+      protocol,
+      standaloneDir: nextStandaloneDir,
+    });
+
+    // Log output based on development or production mode
+    if (isDev) {
+      logger.info(
+        `Development mode: Custom request handler enabled, but Next.js interception disabled`,
+      );
+    } else {
+      logger.info(
+        `Production mode: ${this.nextServerUrl} will be intercepted to ${nextStandaloneDir}`,
+      );
+    }
+
+    this.nextInterceptor = handler.createInterceptor;
+
+    // Save custom handler registration function
+    if (handler.registerCustomHandler) {
+      this.registerCustomHandlerFn = handler.registerCustomHandler;
+      logger.debug('Custom request handler registration is available');
+    } else {
+      logger.warn('Custom request handler registration is not available');
+    }
+  }
+
+  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) => {
+        try {
+          return await controller[methodName](...data);
+        } catch (error) {
+          logger.error(`Error handling IPC event ${key}:`, error);
+          return { error: error.message };
+        }
+      });
+    });
+
+    // Batch register server events from controllers for next server consumption
+    const ipcServerEvents = {} as ElectronIPCEventHandler;
+
+    this.ipcServerEventMap.forEach((eventInfo, key) => {
+      const { controller, methodName } = eventInfo;
+
+      ipcServerEvents[key] = async (payload) => {
+        try {
+          return await controller[methodName](payload);
+        } catch (error) {
+          return { error: error.message };
+        }
+      };
+    });
+
+    this.ipcServer = new ElectronIPCServer(name, ipcServerEvents);
+  }
+
+  // 新增 before-quit 处理函数
+  private handleBeforeQuit = () => {
+    this.isQuiting = true; // 首先设置标志
+
+    // 执行清理操作
+    this.unregisterAllRequestHandlers();
+  };
+}