@lobehub/chat 1.82.10 → 1.83.1

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

@@ -0,0 +1,64 @@
+import { Menu } from 'electron';
+
+import { IMenuPlatform, MenuOptions, createMenuImpl } from '@/menus';
+import { createLogger } from '@/utils/logger';
+
+import type { App } from './App';
+
+// Create logger
+const logger = createLogger('core:MenuManager');
+
+export default class MenuManager {
+  app: App;
+  private platformImpl: IMenuPlatform;
+
+  constructor(app: App) {
+    logger.debug('Initializing MenuManager');
+    this.app = app;
+    this.platformImpl = createMenuImpl(app);
+  }
+
+  /**
+   * Initialize menus (mainly application menu)
+   */
+  initialize(options?: MenuOptions) {
+    logger.info('Initializing application menu');
+    this.platformImpl.buildAndSetAppMenu(options);
+  }
+
+  /**
+   * Build and show context menu
+   */
+  showContextMenu(type: string, data?: any) {
+    logger.debug(`Showing context menu of type: ${type}`);
+    const menu = this.platformImpl.buildContextMenu(type, data);
+    menu.popup(); // popup must be called in main process
+    return { success: true };
+  }
+
+  /**
+   * Build tray menu (usually called by tray manager)
+   */
+  buildTrayMenu(): Menu {
+    logger.debug('Building tray menu');
+    return this.platformImpl.buildTrayMenu();
+  }
+
+  /**
+   * Refresh menus
+   */
+  refreshMenus(options?: MenuOptions) {
+    logger.debug('Refreshing all menus');
+    this.platformImpl.refresh(options);
+    return { success: true };
+  }
+
+  /**
+   * Rebuild and set application menu (e.g., when toggling dev menu visibility)
+   */
+  rebuildAppMenu(options?: MenuOptions) {
+    logger.debug('Rebuilding application menu');
+    this.platformImpl.buildAndSetAppMenu(options);
+    return { success: true };
+  }
+}

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

@@ -0,0 +1,173 @@
+import { globalShortcut } from 'electron';
+
+import { DEFAULT_SHORTCUTS_CONFIG } from '@/shortcuts';
+import { createLogger } from '@/utils/logger';
+
+import type { App } from './App';
+
+// Create logger
+const logger = createLogger('core:ShortcutManager');
+
+export class ShortcutManager {
+  private app: App;
+  private shortcuts: Map<string, () => void> = new Map();
+  private shortcutsConfig: Record<string, string> = {};
+
+  constructor(app: App) {
+    logger.debug('Initializing ShortcutManager');
+    this.app = app;
+
+    app.shortcutMethodMap.forEach((method, key) => {
+      this.shortcuts.set(key, method);
+    });
+  }
+
+  initialize() {
+    logger.info('Initializing global shortcuts');
+    // Load shortcuts configuration from storage
+    this.loadShortcutsConfig();
+    // Register configured shortcuts
+    this.registerConfiguredShortcuts();
+  }
+
+  /**
+   * Get shortcuts configuration
+   */
+  getShortcutsConfig(): Record<string, string> {
+    return this.shortcutsConfig;
+  }
+
+  /**
+   * Update a single shortcut configuration
+   */
+  updateShortcutConfig(id: string, accelerator: string): boolean {
+    try {
+      logger.debug(`Updating shortcut ${id} to ${accelerator}`);
+      // Update configuration
+      this.shortcutsConfig[id] = accelerator;
+
+      this.saveShortcutsConfig();
+      this.registerConfiguredShortcuts();
+      return true;
+    } catch (error) {
+      logger.error(`Error updating shortcut ${id}:`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Register global shortcut
+   * @param accelerator Shortcut key combination
+   * @param callback Callback function
+   * @returns Whether registration was successful
+   */
+  registerShortcut(accelerator: string, callback: () => void): boolean {
+    try {
+      // If already registered, unregister first
+      if (this.shortcuts.has(accelerator)) {
+        this.unregisterShortcut(accelerator);
+      }
+
+      // Register new shortcut
+      const success = globalShortcut.register(accelerator, callback);
+
+      if (success) {
+        this.shortcuts.set(accelerator, callback);
+        logger.debug(`Registered shortcut: ${accelerator}`);
+      } else {
+        logger.error(`Failed to register shortcut: ${accelerator}`);
+      }
+
+      return success;
+    } catch (error) {
+      logger.error(`Error registering shortcut: ${accelerator}`, error);
+      return false;
+    }
+  }
+
+  /**
+   * Unregister global shortcut
+   * @param accelerator Shortcut key combination
+   */
+  unregisterShortcut(accelerator: string): void {
+    try {
+      globalShortcut.unregister(accelerator);
+      this.shortcuts.delete(accelerator);
+      logger.debug(`Unregistered shortcut: ${accelerator}`);
+    } catch (error) {
+      logger.error(`Error unregistering shortcut: ${accelerator}`, error);
+    }
+  }
+
+  /**
+   * Check if a shortcut is already registered
+   * @param accelerator Shortcut key combination
+   * @returns Whether it is registered
+   */
+  isRegistered(accelerator: string): boolean {
+    return globalShortcut.isRegistered(accelerator);
+  }
+
+  /**
+   * Unregister all shortcuts
+   */
+  unregisterAll(): void {
+    globalShortcut.unregisterAll();
+    logger.info('Unregistered all shortcuts');
+  }
+
+  /**
+   * Load shortcuts configuration from storage
+   */
+  private loadShortcutsConfig() {
+    try {
+      // Try to get configuration from storage
+      const config = this.app.storeManager.get('shortcuts');
+
+      // If no configuration, use default configuration
+      if (!config || Object.keys(config).length === 0) {
+        logger.debug('No shortcuts config found, using defaults');
+        this.shortcutsConfig = DEFAULT_SHORTCUTS_CONFIG;
+        this.saveShortcutsConfig();
+      } else {
+        this.shortcutsConfig = config;
+      }
+
+      logger.debug('Loaded shortcuts config:', this.shortcutsConfig);
+    } catch (error) {
+      logger.error('Error loading shortcuts config:', error);
+      this.shortcutsConfig = DEFAULT_SHORTCUTS_CONFIG;
+      this.saveShortcutsConfig();
+    }
+  }
+
+  /**
+   * Save shortcuts configuration to storage
+   */
+  private saveShortcutsConfig() {
+    try {
+      this.app.storeManager.set('shortcuts', this.shortcutsConfig);
+      logger.debug('Saved shortcuts config');
+    } catch (error) {
+      logger.error('Error saving shortcuts config:', error);
+    }
+  }
+
+  /**
+   * Register configured shortcuts
+   */
+  private registerConfiguredShortcuts() {
+    // Unregister all shortcuts first
+    this.unregisterAll();
+
+    // Register each enabled shortcut
+    Object.entries(this.shortcutsConfig).forEach(([id, accelerator]) => {
+      logger.debug(`Registering shortcut '${id}' with ${accelerator}`);
+
+      const method = this.shortcuts.get(id);
+      if (accelerator && method) {
+        this.registerShortcut(accelerator, method);
+      }
+    });
+  }
+}

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

@@ -0,0 +1,89 @@
+import Store from 'electron-store';
+
+import { STORE_DEFAULTS, STORE_NAME } from '@/const/store';
+import { ElectronMainStore, StoreKey } from '@/types/store';
+import { makeSureDirExist } from '@/utils/file-system';
+import { createLogger } from '@/utils/logger';
+
+import { App } from './App';
+
+// Create logger
+const logger = createLogger('core:StoreManager');
+
+/**
+ * Application configuration storage manager
+ */
+export class StoreManager {
+  /**
+   * Global configuration store instance
+   */
+  private store: Store<ElectronMainStore>;
+  private app: App;
+
+  constructor(app: App) {
+    logger.debug('Initializing StoreManager');
+    this.app = app;
+    this.store = new Store<ElectronMainStore>({
+      defaults: STORE_DEFAULTS,
+      name: STORE_NAME,
+    });
+    logger.info('StoreManager initialized with store name:', STORE_NAME);
+
+    const storagePath = this.store.get('storagePath');
+    logger.info('app storage path:', storagePath);
+
+    makeSureDirExist(storagePath);
+  }
+
+  /**
+   * Get configuration item
+   * @param key Configuration key
+   * @param defaultValue Default value
+   */
+  get<K extends StoreKey>(key: K, defaultValue?: ElectronMainStore[K]): ElectronMainStore[K] {
+    logger.debug('Getting configuration value for key:', key);
+    return this.store.get(key, defaultValue as any);
+  }
+
+  /**
+   * Set configuration item
+   * @param key Configuration key
+   * @param value Configuration value
+   */
+  set<K extends StoreKey>(key: K, value: ElectronMainStore[K]): void {
+    logger.debug('Setting configuration value for key:', key);
+    this.store.set(key, value);
+  }
+
+  /**
+   * Delete configuration item
+   * @param key Configuration key
+   */
+  delete(key: StoreKey): void {
+    logger.debug('Deleting configuration key:', key);
+    this.store.delete(key);
+  }
+
+  /**
+   * Clear all storage
+   */
+  clear(): void {
+    logger.warn('Clearing all store data');
+    this.store.clear();
+  }
+
+  /**
+   * Check if a configuration item exists
+   * @param key Configuration key
+   */
+  has(key: StoreKey): boolean {
+    const exists = this.store.has(key);
+    logger.debug('Checking if key exists:', key, exists);
+    return exists;
+  }
+
+  async openInEditor() {
+    logger.info('Opening store in editor');
+    await this.store.openInEditor();
+  }
+}

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

@@ -0,0 +1,321 @@
+import log from 'electron-log';
+import { autoUpdater } from 'electron-updater';
+
+import { isDev } from '@/const/env';
+import { UPDATE_CHANNEL as channel, updaterConfig } from '@/modules/updater/configs';
+import { createLogger } from '@/utils/logger';
+
+import type { App as AppCore } from './App';
+
+// Create logger
+const logger = createLogger('core:UpdaterManager');
+
+export class UpdaterManager {
+  private app: AppCore;
+  private checking: boolean = false;
+  private downloading: boolean = false;
+  private updateAvailable: boolean = false;
+  private isManualCheck: boolean = false;
+
+  constructor(app: AppCore) {
+    this.app = app;
+
+    // 设置日志
+    log.transports.file.level = 'info';
+    autoUpdater.logger = log;
+
+    logger.debug(`[Updater] Log file should be at: ${log.transports.file.getFile().path}`); // 打印路径
+  }
+
+  get mainWindow() {
+    return this.app.browserManager.getMainWindow();
+  }
+
+  public initialize = async () => {
+    logger.debug('Initializing UpdaterManager');
+    // If updates are disabled and in production environment, don't initialize updates
+    if (!updaterConfig.enableAppUpdate && !isDev) {
+      logger.info('App updates are disabled, skipping updater initialization');
+      return;
+    }
+
+    // Configure autoUpdater
+    autoUpdater.autoDownload = false; // Set to false, we'll control downloads manually
+    autoUpdater.autoInstallOnAppQuit = false;
+
+    autoUpdater.channel = channel;
+    autoUpdater.allowPrerelease = channel !== 'stable';
+    autoUpdater.allowDowngrade = false;
+
+    // Enable test mode in development environment
+    if (isDev) {
+      logger.info(`Running in dev mode, forcing update check, channel: ${autoUpdater.channel}`);
+      // Allow testing updates in development environment
+      autoUpdater.forceDevUpdateConfig = true;
+    }
+
+    // Register events
+    this.registerEvents();
+
+    // If auto-check for updates is configured, set up periodic checks
+    if (updaterConfig.app.autoCheckUpdate) {
+      // Delay update check by 1 minute after startup to avoid network instability
+      setTimeout(() => this.checkForUpdates(), 60 * 1000);
+
+      // Set up periodic checks
+      setInterval(() => this.checkForUpdates(), updaterConfig.app.checkUpdateInterval);
+    }
+
+    // Log the channel and allowPrerelease values
+    logger.debug(
+      `Initialized with channel: ${autoUpdater.channel}, allowPrerelease: ${autoUpdater.allowPrerelease}`,
+    );
+
+    logger.info('UpdaterManager initialization completed');
+  };
+
+  /**
+   * Check for updates
+   * @param manual whether this is a manual check for updates
+   */
+  public checkForUpdates = async ({ manual = false }: { manual?: boolean } = {}) => {
+    if (this.checking || this.downloading) return;
+
+    this.checking = true;
+    this.isManualCheck = manual;
+    logger.info(`${manual ? 'Manually checking' : 'Auto checking'} for updates...`);
+
+    // If manual check, notify renderer process about check start
+    if (manual) {
+      this.mainWindow.broadcast('manualUpdateCheckStart');
+    }
+
+    try {
+      await autoUpdater.checkForUpdates();
+    } catch (error) {
+      logger.error('Error checking for updates:', error.message);
+
+      // If manual check, notify renderer process about check error
+      if (manual) {
+        this.mainWindow.broadcast('updateError', (error as Error).message);
+      }
+    } finally {
+      this.checking = false;
+    }
+  };
+
+  /**
+   * Download update
+   * @param manual whether this is a manual download
+   */
+  public downloadUpdate = async (manual: boolean = false) => {
+    if (this.downloading || !this.updateAvailable) return;
+
+    this.downloading = true;
+    logger.info(`${manual ? 'Manually downloading' : 'Auto downloading'} update...`);
+
+    // If manual download or manual check, notify renderer process about download start
+    if (manual || this.isManualCheck) {
+      this.mainWindow.broadcast('updateDownloadStart');
+    }
+
+    try {
+      await autoUpdater.downloadUpdate();
+    } catch (error) {
+      this.downloading = false;
+      logger.error('Error downloading update:', error);
+
+      // If manual download or manual check, notify renderer process about download error
+      if (manual || this.isManualCheck) {
+        this.mainWindow.broadcast('updateError', (error as Error).message);
+      }
+    }
+  };
+
+  /**
+   * Install update immediately
+   */
+  public installNow = () => {
+    logger.info('Installing update now...');
+
+    // Mark application for exit
+    this.app.isQuiting = true;
+
+    // Delay installation by 1 second to ensure window is closed
+    autoUpdater.quitAndInstall();
+  };
+
+  /**
+   * Install update on next launch
+   */
+  public installLater = () => {
+    logger.info('Update will be installed on next restart');
+
+    // Mark for installation on next launch, but don't exit application
+    autoUpdater.autoInstallOnAppQuit = true;
+
+    // Notify renderer process that update will be installed on next launch
+    this.mainWindow.broadcast('updateWillInstallLater');
+  };
+
+  /**
+   * Test mode: Simulate update available
+   * Only for use in development environment
+   */
+  public simulateUpdateAvailable = () => {
+    if (!isDev) return;
+
+    logger.info('Simulating update available...');
+
+    const mainWindow = this.mainWindow;
+    // Simulate a new version update
+    const mockUpdateInfo = {
+      releaseDate: new Date().toISOString(),
+      releaseNotes: ` #### Version 1.0.0 Release Notes
+- Added some great new features
+- Fixed bugs affecting usability
+- Optimized overall application performance
+- Updated dependency libraries
+`,
+      version: '1.0.0',
+    };
+
+    // Set update available state
+    this.updateAvailable = true;
+
+    // Notify renderer process
+    if (this.isManualCheck) {
+      mainWindow.broadcast('manualUpdateAvailable', mockUpdateInfo);
+    } else {
+      // In auto-check mode, directly simulate download
+      this.simulateDownloadProgress();
+    }
+  };
+
+  /**
+   * Test mode: Simulate update downloaded
+   * Only for use in development environment
+   */
+  public simulateUpdateDownloaded = () => {
+    if (!isDev) return;
+
+    logger.info('Simulating update downloaded...');
+
+    const mainWindow = this.app.browserManager.getMainWindow();
+    if (mainWindow) {
+      // Simulate a new version update
+      const mockUpdateInfo = {
+        releaseDate: new Date().toISOString(),
+        releaseNotes: ` #### Version 1.0.0 Release Notes
+- Added some great new features
+- Fixed bugs affecting usability
+- Optimized overall application performance
+- Updated dependency libraries
+`,
+        version: '1.0.0',
+      };
+
+      // Set download state
+      this.downloading = false;
+
+      // Notify renderer process
+      mainWindow.broadcast('updateDownloaded', mockUpdateInfo);
+    }
+  };
+
+  /**
+   * Test mode: Simulate update download progress
+   * Only for use in development environment
+   */
+  public simulateDownloadProgress = () => {
+    if (!isDev) return;
+
+    logger.info('Simulating download progress...');
+
+    const mainWindow = this.app.browserManager.getMainWindow();
+
+    // Set download state
+    this.downloading = true;
+
+    // Only broadcast download start event if manual check
+    if (this.isManualCheck) {
+      mainWindow.broadcast('updateDownloadStart');
+    }
+
+    // Simulate progress updates
+    let progress = 0;
+    const interval = setInterval(() => {
+      progress += 10;
+
+      if (
+        progress <= 100 && // Only broadcast download progress if manual check
+        this.isManualCheck
+      ) {
+        mainWindow.broadcast('updateDownloadProgress', {
+          bytesPerSecond: 1024 * 1024,
+          percent: progress, // 1MB/s
+          total: 1024 * 1024 * 100, // 100MB
+          transferred: 1024 * 1024 * progress, // Progress * 1MB
+        });
+      }
+
+      if (progress >= 100) {
+        clearInterval(interval);
+        this.simulateUpdateDownloaded();
+      }
+    }, 300);
+  };
+
+  private registerEvents() {
+    logger.debug('Registering updater events');
+
+    autoUpdater.on('checking-for-update', () => {
+      logger.info('[Updater] Checking for update...');
+    });
+
+    autoUpdater.on('update-available', (info) => {
+      logger.info(`Update available: ${info.version}`);
+      this.updateAvailable = true;
+
+      if (this.isManualCheck) {
+        this.mainWindow.broadcast('manualUpdateAvailable', info);
+      } else {
+        // If it's an automatic check, start downloading automatically
+        logger.info('Auto check found update, starting download automatically...');
+        this.downloadUpdate();
+      }
+    });
+
+    autoUpdater.on('update-not-available', (info) => {
+      logger.info(`Update not available. Current: ${info.version}`);
+      if (this.isManualCheck) {
+        this.mainWindow.broadcast('manualUpdateNotAvailable', info);
+      }
+    });
+
+    autoUpdater.on('error', (err) => {
+      logger.error('Error in auto-updater:', err);
+      if (this.isManualCheck) {
+        this.mainWindow.broadcast('updateError', err.message);
+      }
+    });
+
+    autoUpdater.on('download-progress', (progressObj) => {
+      logger.debug(
+        `Download speed: ${progressObj.bytesPerSecond} - Downloaded ${progressObj.percent}% (${progressObj.transferred}/${progressObj.total})`,
+      );
+      if (this.isManualCheck) {
+        this.mainWindow.broadcast('updateDownloadProgress', progressObj);
+      }
+    });
+
+    autoUpdater.on('update-downloaded', (info) => {
+      logger.info(`Update downloaded: ${info.version}`);
+      this.downloading = false;
+      // Always notify about downloaded update
+      this.mainWindow.broadcast('updateDownloaded', info);
+    });
+
+    logger.debug('Updater events registered');
+  }
+}

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

@@ -0,0 +1,5 @@
+import { App } from './core/App';
+
+const app = new App();
+
+app.bootstrap();

package/apps/desktop/src/main/locales/default/common.ts

@@ -0,0 +1,34 @@
+const common = {
+  actions: {
+    add: '添加',
+    back: '返回',
+    cancel: '取消',
+    close: '关闭',
+    confirm: '确认',
+    delete: '删除',
+    edit: '编辑',
+    more: '更多',
+    next: '下一步',
+    ok: '确定',
+    previous: '上一步',
+    refresh: '刷新',
+    remove: '移除',
+    retry: '重试',
+    save: '保存',
+    search: '搜索',
+    submit: '提交',
+  },
+  app: {
+    description: '你的 AI 助手协作平台',
+    name: 'LobeHub',
+  },
+  status: {
+    error: '错误',
+    info: '信息',
+    loading: '加载中',
+    success: '成功',
+    warning: '警告',
+  },
+};
+
+export default common;