@lobehub/chat 1.82.9 → 1.83.0

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

@@ -0,0 +1,345 @@
+import { MainBroadcastEventKey, MainBroadcastParams } from '@lobechat/electron-client-ipc';
+import { BrowserWindow, BrowserWindowConstructorOptions, ipcMain } from 'electron';
+import { join } from 'node:path';
+
+import { createLogger } from '@/utils/logger';
+
+import { preloadDir, resourcesDir } from '../const/dir';
+import type { App } from './App';
+
+// Create logger
+const logger = createLogger('core:Browser');
+
+export interface BrowserWindowOpts extends BrowserWindowConstructorOptions {
+  devTools?: boolean;
+  height?: number;
+  /**
+   * URL
+   */
+  identifier: string;
+  keepAlive?: boolean;
+  path: string;
+  showOnInit?: boolean;
+  title?: string;
+  width?: number;
+}
+
+export default class Browser {
+  private app: App;
+
+  /**
+   * Internal electron window
+   */
+  private _browserWindow?: BrowserWindow;
+
+  private stopInterceptHandler;
+  /**
+   * Identifier
+   */
+  identifier: string;
+
+  /**
+   * Options at creation
+   */
+  options: BrowserWindowOpts;
+
+  /**
+   * Key for storing window state in storeManager
+   */
+  private readonly windowStateKey: string;
+
+  /**
+   * Method to expose window externally
+   */
+  get browserWindow() {
+    return this.retrieveOrInitialize();
+  }
+
+  /**
+   * Method to construct BrowserWindows object
+   * @param options
+   * @param application
+   */
+  constructor(options: BrowserWindowOpts, application: App) {
+    logger.debug(`Creating Browser instance: ${options.identifier}`);
+    logger.debug(`Browser options: ${JSON.stringify(options)}`);
+    this.app = application;
+    this.identifier = options.identifier;
+    this.options = options;
+    this.windowStateKey = `windowSize_${this.identifier}`;
+
+    // Initialization
+    this.retrieveOrInitialize();
+  }
+
+  loadUrl = async (path: string) => {
+    const initUrl = this.app.nextServerUrl + path;
+
+    try {
+      logger.debug(`[${this.identifier}] Attempting to load URL: ${initUrl}`);
+      await this._browserWindow.loadURL(initUrl);
+      logger.debug(`[${this.identifier}] Successfully loaded URL: ${initUrl}`);
+    } catch (error) {
+      logger.error(`[${this.identifier}] Failed to load URL (${initUrl}):`, error);
+
+      // Try to load local error page
+      try {
+        logger.info(`[${this.identifier}] Attempting to load error page...`);
+        await this._browserWindow.loadFile(join(resourcesDir, 'error.html'));
+        logger.info(`[${this.identifier}] Error page loaded successfully.`);
+
+        // Remove previously set retry listeners to avoid duplicates
+        ipcMain.removeHandler('retry-connection');
+        logger.debug(`[${this.identifier}] Removed existing retry-connection handler if any.`);
+
+        // Set retry logic
+        ipcMain.handle('retry-connection', async () => {
+          logger.info(`[${this.identifier}] Retry connection requested for: ${initUrl}`);
+          try {
+            await this._browserWindow?.loadURL(initUrl);
+            logger.info(`[${this.identifier}] Reconnection successful to ${initUrl}`);
+            return { success: true };
+          } catch (err) {
+            logger.error(`[${this.identifier}] Retry connection failed for ${initUrl}:`, err);
+            // Reload error page
+            try {
+              logger.info(`[${this.identifier}] Reloading error page after failed retry...`);
+              await this._browserWindow?.loadFile(join(resourcesDir, 'error.html'));
+              logger.info(`[${this.identifier}] Error page reloaded.`);
+            } catch (loadErr) {
+              logger.error('[${this.identifier}] Failed to reload error page:', loadErr);
+            }
+            return { error: err.message, success: false };
+          }
+        });
+        logger.debug(`[${this.identifier}] Set up retry-connection handler.`);
+      } catch (err) {
+        logger.error(`[${this.identifier}] Failed to load error page:`, err);
+        // If even the error page can't be loaded, at least show a simple error message
+        try {
+          logger.warn(`[${this.identifier}] Attempting to load fallback error HTML string...`);
+          await this._browserWindow.loadURL(
+            'data:text/html,<html><body><h1>Loading Failed</h1><p>Unable to connect to server, please restart the application</p></body></html>',
+          );
+          logger.info(`[${this.identifier}] Fallback error HTML string loaded.`);
+        } catch (finalErr) {
+          logger.error(`[${this.identifier}] Unable to display any page:`, finalErr);
+        }
+      }
+    }
+  };
+
+  loadPlaceholder = async () => {
+    logger.debug(`[${this.identifier}] Loading splash screen placeholder`);
+    // First load a local HTML loading page
+    await this._browserWindow.loadFile(join(resourcesDir, 'splash.html'));
+    logger.debug(`[${this.identifier}] Splash screen placeholder loaded.`);
+  };
+
+  show() {
+    logger.debug(`Showing window: ${this.identifier}`);
+    this.browserWindow.show();
+  }
+
+  hide() {
+    logger.debug(`Hiding window: ${this.identifier}`);
+    this.browserWindow.hide();
+  }
+
+  close() {
+    logger.debug(`Attempting to close window: ${this.identifier}`);
+    this.browserWindow.close();
+  }
+
+  /**
+   * Destroy instance
+   */
+  destroy() {
+    logger.debug(`Destroying window instance: ${this.identifier}`);
+    this.stopInterceptHandler?.();
+    this._browserWindow = undefined;
+  }
+
+  /**
+   * Initialize
+   */
+  retrieveOrInitialize() {
+    // When there is this window and it has not been destroyed
+    if (this._browserWindow && !this._browserWindow.isDestroyed()) {
+      logger.debug(`[${this.identifier}] Returning existing BrowserWindow instance.`);
+      return this._browserWindow;
+    }
+
+    const { path, title, width, height, devTools, showOnInit, ...res } = this.options;
+
+    // Load window state
+    const savedState = this.app.storeManager.get(this.windowStateKey as any) as
+      | { height?: number; width?: number }
+      | undefined; // Keep type for now, but only use w/h
+    logger.info(`Creating new BrowserWindow instance: ${this.identifier}`);
+    logger.debug(`[${this.identifier}] Options for new window: ${JSON.stringify(this.options)}`);
+    logger.debug(
+      `[${this.identifier}] Saved window state (only size used): ${JSON.stringify(savedState)}`,
+    );
+
+    const browserWindow = new BrowserWindow({
+      ...res,
+
+      height: savedState?.height || height,
+
+      show: false,
+
+      // Always create hidden first
+      title,
+
+      transparent: true,
+
+      webPreferences: {
+        // Context isolation environment
+        // https://www.electronjs.org/docs/tutorial/context-isolation
+        contextIsolation: true,
+        preload: join(preloadDir, 'index.js'),
+        // devTools: isDev,
+      },
+      // Use saved state if available, otherwise use options. Do not set x/y
+      // x: savedState?.x, // Don't restore x
+      // y: savedState?.y, // Don't restore y
+      width: savedState?.width || width,
+    });
+
+    this._browserWindow = browserWindow;
+    logger.debug(`[${this.identifier}] BrowserWindow instance created.`);
+
+    logger.debug(`[${this.identifier}] Setting up nextInterceptor.`);
+    this.stopInterceptHandler = this.app.nextInterceptor({
+      session: browserWindow.webContents.session,
+    });
+
+    // Windows 11 can use this new API
+    if (process.platform === 'win32' && browserWindow.setBackgroundMaterial) {
+      logger.debug(`[${this.identifier}] Setting window background material for Windows 11`);
+      browserWindow.setBackgroundMaterial('acrylic');
+    }
+
+    logger.debug(`[${this.identifier}] Initiating placeholder and URL loading sequence.`);
+    this.loadPlaceholder().then(() => {
+      this.loadUrl(path).catch((e) => {
+        logger.error(`[${this.identifier}] Initial loadUrl error for path '${path}':`, e);
+      });
+    });
+
+    // Show devtools if enabled
+    if (devTools) {
+      logger.debug(`[${this.identifier}] Opening DevTools because devTools option is true.`);
+      browserWindow.webContents.openDevTools();
+    }
+
+    logger.debug(`[${this.identifier}] Setting up 'ready-to-show' event listener.`);
+    browserWindow.once('ready-to-show', () => {
+      logger.debug(`[${this.identifier}] Window 'ready-to-show' event fired.`);
+      if (showOnInit) {
+        logger.debug(`Showing window ${this.identifier} because showOnInit is true.`);
+        browserWindow?.show();
+      } else {
+        logger.debug(
+          `Window ${this.identifier} not shown on 'ready-to-show' because showOnInit is false.`,
+        );
+      }
+    });
+
+    logger.debug(`[${this.identifier}] Setting up 'close' event listener.`);
+    browserWindow.on('close', (e) => {
+      logger.debug(`Window 'close' event triggered for: ${this.identifier}`);
+      logger.debug(
+        `[${this.identifier}] State during close event: isQuiting=${this.app.isQuiting}, keepAlive=${this.options.keepAlive}`,
+      );
+
+      // If in application quitting process, allow window to be closed
+      if (this.app.isQuiting) {
+        logger.debug(`[${this.identifier}] App is quitting, allowing window to close naturally.`);
+        // Save state before quitting
+        try {
+          const { width, height } = browserWindow.getBounds(); // Get only width and height
+          const sizeState = { height, width };
+          logger.debug(
+            `[${this.identifier}] Saving window size on quit: ${JSON.stringify(sizeState)}`,
+          );
+          this.app.storeManager.set(this.windowStateKey as any, sizeState); // Save only size
+        } catch (error) {
+          logger.error(`[${this.identifier}] Failed to save window state on quit:`, error);
+        }
+        // Need to clean up intercept handler
+        this.stopInterceptHandler?.();
+        return;
+      }
+
+      // Prevent window from being destroyed, just hide it (if marked as keepAlive)
+      if (this.options.keepAlive) {
+        logger.debug(
+          `[${this.identifier}] keepAlive is true, preventing default close and hiding window.`,
+        );
+        // Optionally save state when hiding if desired, but primary save is on actual close/quit
+        // try {
+        //   const bounds = browserWindow.getBounds();
+        //   logger.debug(`[${this.identifier}] Saving window state on hide: ${JSON.stringify(bounds)}`);
+        //   this.app.storeManager.set(this.windowStateKey, bounds);
+        // } catch (error) {
+        //   logger.error(`[${this.identifier}] Failed to save window state on hide:`, error);
+        // }
+        e.preventDefault();
+        browserWindow.hide();
+      } else {
+        // Window is actually closing (not keepAlive)
+        logger.debug(
+          `[${this.identifier}] keepAlive is false, allowing window to close. Saving size...`, // Updated log message
+        );
+        try {
+          const { width, height } = browserWindow.getBounds(); // Get only width and height
+          const sizeState = { height, width };
+          logger.debug(
+            `[${this.identifier}] Saving window size on close: ${JSON.stringify(sizeState)}`,
+          );
+          this.app.storeManager.set(this.windowStateKey as any, sizeState); // Save only size
+        } catch (error) {
+          logger.error(`[${this.identifier}] Failed to save window state on close:`, error);
+        }
+        // Need to clean up intercept handler
+        this.stopInterceptHandler?.();
+      }
+    });
+
+    logger.debug(`[${this.identifier}] retrieveOrInitialize completed.`);
+    return browserWindow;
+  }
+
+  moveToCenter() {
+    logger.debug(`Centering window: ${this.identifier}`);
+    this._browserWindow?.center();
+  }
+
+  setWindowSize(boundSize: { height?: number; width?: number }) {
+    logger.debug(
+      `Setting window size for ${this.identifier}: width=${boundSize.width}, height=${boundSize.height}`,
+    );
+    const windowSize = this._browserWindow.getBounds();
+    this._browserWindow?.setBounds({
+      height: boundSize.height || windowSize.height,
+      width: boundSize.width || windowSize.width,
+    });
+  }
+
+  broadcast = <T extends MainBroadcastEventKey>(channel: T, data?: MainBroadcastParams<T>) => {
+    logger.debug(`Broadcasting to window ${this.identifier}, channel: ${channel}`);
+    this._browserWindow.webContents.send(channel, data);
+  };
+
+  toggleVisible() {
+    logger.debug(`Toggling visibility for window: ${this.identifier}`);
+    if (this._browserWindow.isVisible() && this._browserWindow.isFocused()) {
+      this._browserWindow.hide();
+    } else {
+      this._browserWindow.show();
+      this._browserWindow.focus();
+    }
+  }
+}

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

@@ -0,0 +1,154 @@
+import { MainBroadcastEventKey, MainBroadcastParams } from '@lobechat/electron-client-ipc';
+
+import { createLogger } from '@/utils/logger';
+
+import { AppBrowsersIdentifiers, appBrowsers } from '../appBrowsers';
+import type { App } from './App';
+import type { BrowserWindowOpts } from './Browser';
+import Browser from './Browser';
+
+// Create logger
+const logger = createLogger('core:BrowserManager');
+
+export default class BrowserManager {
+  app: App;
+
+  browsers: Map<AppBrowsersIdentifiers, Browser> = new Map();
+
+  constructor(app: App) {
+    logger.debug('Initializing BrowserManager');
+    this.app = app;
+  }
+
+  getMainWindow() {
+    return this.retrieveByIdentifier('chat');
+  }
+
+  showMainWindow() {
+    logger.debug('Showing main window');
+    const window = this.getMainWindow();
+    window.show();
+  }
+
+  showSettingsWindow() {
+    logger.debug('Showing settings window');
+    const window = this.retrieveByIdentifier('settings');
+    window.show();
+    return window;
+  }
+
+  broadcastToAllWindows = <T extends MainBroadcastEventKey>(
+    event: T,
+    data: MainBroadcastParams<T>,
+  ) => {
+    logger.debug(`Broadcasting event ${event} to all windows`);
+    this.browsers.forEach((browser) => {
+      browser.broadcast(event, data);
+    });
+  };
+
+  broadcastToWindow = <T extends MainBroadcastEventKey>(
+    identifier: AppBrowsersIdentifiers,
+    event: T,
+    data: MainBroadcastParams<T>,
+  ) => {
+    logger.debug(`Broadcasting event ${event} to window: ${identifier}`);
+    this.browsers.get(identifier).broadcast(event, data);
+  };
+
+  /**
+   * Display the settings window and navigate to a specific tab
+   * @param tab Settings window sub-path tab
+   */
+  async showSettingsWindowWithTab(tab?: string) {
+    logger.debug(`Showing settings window with tab: ${tab || 'default'}`);
+    // common is the main path for settings route
+    if (tab && tab !== 'common') {
+      const browser = await this.redirectToPage('settings', tab);
+
+      // make provider page more large
+      if (tab.startsWith('provider/')) {
+        logger.debug('Resizing window for provider settings');
+        browser.setWindowSize({ height: 1000, width: 1400 });
+        browser.moveToCenter();
+      }
+
+      return browser;
+    } else {
+      return this.showSettingsWindow();
+    }
+  }
+
+  /**
+   * Navigate window to specific sub-path
+   * @param identifier Window identifier
+   * @param subPath Sub-path, such as 'agent', 'about', etc.
+   */
+  async redirectToPage(identifier: AppBrowsersIdentifiers, subPath?: string) {
+    try {
+      // Ensure window is retrieved or created
+      const browser = this.retrieveByIdentifier(identifier);
+      browser.hide();
+
+      const baseRoute = appBrowsers[identifier].path;
+
+      // Build complete URL path
+      const fullPath = subPath ? `${baseRoute}/${subPath}` : baseRoute;
+
+      logger.debug(`Redirecting to: ${fullPath}`);
+
+      // Load URL and show window
+      await browser.loadUrl(fullPath);
+      browser.show();
+
+      return browser;
+    } catch (error) {
+      logger.error(`Failed to redirect (${identifier}/${subPath}):`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * get Browser by identifier
+   */
+  retrieveByIdentifier(identifier: AppBrowsersIdentifiers) {
+    const browser = this.browsers.get(identifier);
+
+    if (browser) return browser;
+
+    logger.debug(`Browser ${identifier} not found, initializing new instance`);
+    return this.retrieveOrInitialize(appBrowsers[identifier]);
+  }
+
+  /**
+   * Initialize all browsers when app starts up
+   */
+  initializeBrowsers() {
+    logger.info('Initializing all browsers');
+    Object.values(appBrowsers).forEach((browser) => {
+      logger.debug(`Initializing browser: ${browser.identifier}`);
+      this.retrieveOrInitialize(browser);
+    });
+  }
+
+  // helper
+
+  /**
+   * Retrieve existing browser or initialize a new one
+   * @param options Browser window options
+   */
+  private retrieveOrInitialize(options: BrowserWindowOpts) {
+    let browser = this.browsers.get(options.identifier as AppBrowsersIdentifiers);
+    if (browser) {
+      logger.debug(`Retrieved existing browser: ${options.identifier}`);
+      return browser;
+    }
+
+    logger.debug(`Creating new browser: ${options.identifier}`);
+    browser = new Browser(options, this.app);
+
+    this.browsers.set(options.identifier as AppBrowsersIdentifiers, browser);
+
+    return browser;
+  }
+}

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

@@ -0,0 +1,185 @@
+import { app } from 'electron';
+import i18next from 'i18next';
+
+import { App } from '@/core/App';
+import { loadResources } from '@/locales/resources';
+import { createLogger } from '@/utils/logger';
+
+// Create logger
+const logger = createLogger('core:I18nManager');
+
+export class I18nManager {
+  private i18n: typeof i18next;
+  private initialized: boolean = false;
+  private app: App;
+
+  constructor(app: App) {
+    logger.debug('Initializing I18nManager');
+    this.app = app;
+    this.i18n = i18next.createInstance();
+  }
+
+  /**
+   * Initialize i18next instance
+   */
+  async init(lang?: string) {
+    if (this.initialized) {
+      logger.debug('I18nManager already initialized, skipping');
+      return this.i18n;
+    }
+
+    // Priority: parameter language > stored locale > system language
+    const storedLocale = this.app.storeManager.get('locale', 'auto') as string;
+    const defaultLanguage =
+      lang || (storedLocale !== 'auto' ? storedLocale : app.getLocale()) || 'en-US';
+
+    logger.info(
+      `Initializing i18n, app locale: ${defaultLanguage}, stored locale: ${storedLocale}`,
+    );
+
+    await this.i18n.init({
+      defaultNS: 'menu',
+      fallbackLng: 'en-US',
+      // Load resources as needed
+      initAsync: true,
+      interpolation: {
+        escapeValue: false,
+      },
+
+      lng: defaultLanguage,
+
+      ns: ['menu', 'dialog', 'common'],
+      partialBundledLanguages: true,
+    });
+
+    logger.info(`i18n initialized, language: ${this.i18n.language}`);
+
+    // Preload base namespaces
+    await this.loadLocale(this.i18n.language);
+
+    this.initialized = true;
+
+    this.refreshMainUI();
+
+    // Listen for language change events
+    this.i18n.on('languageChanged', this.handleLanguageChanged);
+
+    return this.i18n;
+  }
+
+  /**
+   * Basic translation function
+   */
+  t = (key: string, options?: any) => {
+    const result = this.i18n.t(key, options) as string;
+
+    // If translation result is the same as key, translation might be missing
+    if (result === key) {
+      logger.warn(`${this.i18n.language} key: ${key} is not found`);
+    }
+
+    return result;
+  };
+
+  /**
+   * Create a translation function bound to a specific namespace
+   * @param namespace Namespace
+   * @returns Translation function bound to namespace
+   */
+  createNamespacedT(namespace: string) {
+    return (key: string, options: any = {}) => {
+      // Copy options to avoid modifying the original object
+      const mergedOptions = { ...options };
+      // Set namespace
+      mergedOptions.ns = namespace;
+
+      return this.t(key, mergedOptions);
+    };
+  }
+
+  /**
+   * Get translation function by namespace
+   * Provides a more convenient calling method
+   */
+  ns = (namespace: string) => this.createNamespacedT(namespace);
+
+  /**
+   * Get current language
+   */
+  getCurrentLanguage() {
+    return this.i18n.language;
+  }
+
+  /**
+   * Change application language
+   * @param lng Target language
+   */
+  public async changeLanguage(lng: string): Promise<void> {
+    logger.info(`Changing language to: ${lng}`);
+
+    if (!this.initialized) {
+      await this.init();
+    }
+
+    await this.i18n.changeLanguage(lng);
+    // Language change event will trigger handleLanguageChanged
+  }
+
+  /**
+   * Handle language change event
+   */
+  private handleLanguageChanged = async (lang: string) => {
+    logger.info(`Language changed to: ${lang}`);
+    await this.loadLocale(lang);
+
+    // Notify other parts of main process to refresh UI
+    this.refreshMainUI();
+  };
+
+  /**
+   * Refresh main process UI (menus, etc.)
+   */
+  private refreshMainUI() {
+    logger.debug('Refreshing main UI after language change');
+    this.app.menuManager.refreshMenus();
+  }
+
+  /**
+   * Notify renderer process that language has changed
+   */
+  private notifyRendererProcess(lng: string) {
+    logger.debug(`Notifying renderer process of language change: ${lng}`);
+
+    // Send language change event to all windows
+    // const windows = this.app.browserManager.windows;
+    //
+    // if (windows && windows.length > 0) {
+    //   windows.forEach((window) => {
+    //     if (window?.webContents) {
+    //       window.webContents.send('language-changed', lng);
+    //     }
+    //   });
+    // }
+  }
+
+  private async loadLocale(language: string) {
+    logger.debug(`Loading locale for language: ${language}`);
+    // Preload base namespaces
+    await Promise.all(['menu', 'dialog', 'common'].map((ns) => this.loadNamespace(language, ns)));
+  }
+
+  /**
+   * Load translation resources for specific namespace
+   */
+  private async loadNamespace(lng: string, ns: string) {
+    try {
+      logger.debug(`Loading namespace: ${lng}/${ns}`);
+      const resources = await loadResources(lng, ns);
+      this.i18n.addResourceBundle(lng, ns, resources, true, true);
+      return true;
+    } catch (error) {
+      logger.error(`Failed to load namespace: ${lng}/${ns}`, error);
+      return false;
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 存储应用中需要用装饰器的类
+ */
+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();
+  init() {}
+}