@lobehub/lobehub 2.0.0-next.242 → 2.0.0-next.243

package/apps/desktop/src/main/core/browser/__tests__/WindowThemeManager.test.ts

@@ -0,0 +1,240 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { WindowThemeManager } from '../WindowThemeManager';
+
+// Use vi.hoisted to define mocks before hoisting
+const { mockNativeTheme, mockBrowserWindow } = vi.hoisted(() => ({
+  mockBrowserWindow: {
+    isDestroyed: vi.fn().mockReturnValue(false),
+    setBackgroundColor: vi.fn(),
+    setTitleBarOverlay: vi.fn(),
+  },
+  mockNativeTheme: {
+    off: vi.fn(),
+    on: vi.fn(),
+    shouldUseDarkColors: false,
+  },
+}));
+
+vi.mock('electron', () => ({
+  nativeTheme: mockNativeTheme,
+}));
+
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+vi.mock('@/const/dir', () => ({
+  buildDir: '/mock/build',
+}));
+
+vi.mock('@/const/env', () => ({
+  isDev: false,
+  isWindows: true,
+}));
+
+vi.mock('@/const/theme', () => ({
+  BACKGROUND_DARK: '#1a1a1a',
+  BACKGROUND_LIGHT: '#ffffff',
+  SYMBOL_COLOR_DARK: '#ffffff',
+  SYMBOL_COLOR_LIGHT: '#000000',
+  THEME_CHANGE_DELAY: 0,
+  TITLE_BAR_HEIGHT: 32,
+}));
+
+describe('WindowThemeManager', () => {
+  let manager: WindowThemeManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+
+    mockNativeTheme.shouldUseDarkColors = false;
+    mockBrowserWindow.isDestroyed.mockReturnValue(false);
+
+    manager = new WindowThemeManager('test-window');
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('isDarkMode', () => {
+    it('should return true when shouldUseDarkColors is true', () => {
+      mockNativeTheme.shouldUseDarkColors = true;
+
+      expect(manager.isDarkMode).toBe(true);
+    });
+
+    it('should return false when shouldUseDarkColors is false', () => {
+      mockNativeTheme.shouldUseDarkColors = false;
+
+      expect(manager.isDarkMode).toBe(false);
+    });
+  });
+
+  describe('getPlatformConfig', () => {
+    it('should return Windows dark theme config when in dark mode', () => {
+      mockNativeTheme.shouldUseDarkColors = true;
+
+      const config = manager.getPlatformConfig();
+
+      expect(config).toEqual({
+        backgroundColor: '#1a1a1a',
+        icon: undefined,
+        titleBarOverlay: {
+          color: '#1a1a1a',
+          height: 32,
+          symbolColor: '#ffffff',
+        },
+        titleBarStyle: 'hidden',
+      });
+    });
+
+    it('should return Windows light theme config when in light mode', () => {
+      mockNativeTheme.shouldUseDarkColors = false;
+
+      const config = manager.getPlatformConfig();
+
+      expect(config).toEqual({
+        backgroundColor: '#ffffff',
+        icon: undefined,
+        titleBarOverlay: {
+          color: '#ffffff',
+          height: 32,
+          symbolColor: '#000000',
+        },
+        titleBarStyle: 'hidden',
+      });
+    });
+  });
+
+  describe('attach', () => {
+    it('should setup theme listener', () => {
+      manager.attach(mockBrowserWindow as any);
+
+      expect(mockNativeTheme.on).toHaveBeenCalledWith('updated', expect.any(Function));
+    });
+
+    it('should apply initial visual effects', () => {
+      manager.attach(mockBrowserWindow as any);
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalled();
+      expect(mockBrowserWindow.setTitleBarOverlay).toHaveBeenCalled();
+    });
+
+    it('should not setup duplicate listeners', () => {
+      manager.attach(mockBrowserWindow as any);
+      manager.attach(mockBrowserWindow as any);
+
+      expect(mockNativeTheme.on).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should remove theme listener', () => {
+      manager.attach(mockBrowserWindow as any);
+      manager.cleanup();
+
+      expect(mockNativeTheme.off).toHaveBeenCalledWith('updated', expect.any(Function));
+    });
+
+    it('should not throw if cleanup called without attach', () => {
+      expect(() => manager.cleanup()).not.toThrow();
+      expect(mockNativeTheme.off).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleAppThemeChange', () => {
+    it('should reapply visual effects after delay', () => {
+      manager.attach(mockBrowserWindow as any);
+      mockBrowserWindow.setBackgroundColor.mockClear();
+      mockBrowserWindow.setTitleBarOverlay.mockClear();
+
+      manager.handleAppThemeChange();
+      vi.advanceTimersByTime(0);
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalled();
+      expect(mockBrowserWindow.setTitleBarOverlay).toHaveBeenCalled();
+    });
+  });
+
+  describe('reapplyVisualEffects', () => {
+    it('should apply visual effects', () => {
+      manager.attach(mockBrowserWindow as any);
+      mockBrowserWindow.setBackgroundColor.mockClear();
+
+      manager.reapplyVisualEffects();
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalled();
+    });
+  });
+
+  describe('applyVisualEffects', () => {
+    it('should apply dark theme when in dark mode', () => {
+      mockNativeTheme.shouldUseDarkColors = true;
+      manager.attach(mockBrowserWindow as any);
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#1a1a1a');
+      expect(mockBrowserWindow.setTitleBarOverlay).toHaveBeenCalledWith({
+        color: '#1a1a1a',
+        height: 32,
+        symbolColor: '#ffffff',
+      });
+    });
+
+    it('should apply light theme when in light mode', () => {
+      mockNativeTheme.shouldUseDarkColors = false;
+      manager.attach(mockBrowserWindow as any);
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalledWith('#ffffff');
+      expect(mockBrowserWindow.setTitleBarOverlay).toHaveBeenCalledWith({
+        color: '#ffffff',
+        height: 32,
+        symbolColor: '#000000',
+      });
+    });
+
+    it('should not apply effects when window is destroyed', () => {
+      manager.attach(mockBrowserWindow as any);
+      mockBrowserWindow.setBackgroundColor.mockClear();
+      mockBrowserWindow.isDestroyed.mockReturnValue(true);
+
+      manager.reapplyVisualEffects();
+
+      expect(mockBrowserWindow.setBackgroundColor).not.toHaveBeenCalled();
+    });
+
+    it('should not apply effects when no window attached', () => {
+      // Manager without attached window
+      const freshManager = new WindowThemeManager('fresh-window');
+
+      // Should not throw
+      expect(() => freshManager.reapplyVisualEffects()).not.toThrow();
+    });
+  });
+
+  describe('theme change listener', () => {
+    it('should reapply visual effects on system theme change', () => {
+      manager.attach(mockBrowserWindow as any);
+
+      // Get the theme change handler
+      const themeHandler = mockNativeTheme.on.mock.calls.find((call) => call[0] === 'updated')?.[1];
+
+      expect(themeHandler).toBeDefined();
+
+      mockBrowserWindow.setBackgroundColor.mockClear();
+
+      // Simulate theme change
+      themeHandler();
+      vi.advanceTimersByTime(0);
+
+      expect(mockBrowserWindow.setBackgroundColor).toHaveBeenCalled();
+    });
+  });
+});

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

@@ -5,4 +5,4 @@ declare module '@lobechat/electron-client-ipc' {
   interface DesktopIpcServicesMap extends DesktopIpcServices {}
 }
 
-export { type DesktopIpcServices, type DesktopServerIpcServices } from './controllers/registry';
+export { type DesktopIpcServices } from './controllers/registry';

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

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

package/apps/desktop/src/main/utils/__tests__/http-headers.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  deleteResponseHeader,
+  getResponseHeader,
+  hasResponseHeader,
+  setResponseHeader,
+} from '../http-headers';
+
+describe('http-headers utilities', () => {
+  describe('setResponseHeader', () => {
+    it('should set a new header', () => {
+      const headers: Record<string, string[]> = {};
+
+      setResponseHeader(headers, 'Content-Type', 'application/json');
+
+      expect(headers['Content-Type']).toEqual(['application/json']);
+    });
+
+    it('should replace existing header with same case', () => {
+      const headers: Record<string, string[]> = {
+        'Content-Type': ['text/html'],
+      };
+
+      setResponseHeader(headers, 'Content-Type', 'application/json');
+
+      expect(headers['Content-Type']).toEqual(['application/json']);
+      expect(Object.keys(headers)).toHaveLength(1);
+    });
+
+    it('should replace existing header with different case', () => {
+      const headers: Record<string, string[]> = {
+        'content-type': ['text/html'],
+      };
+
+      setResponseHeader(headers, 'Content-Type', 'application/json');
+
+      expect(headers['Content-Type']).toEqual(['application/json']);
+      expect(headers['content-type']).toBeUndefined();
+      expect(Object.keys(headers)).toHaveLength(1);
+    });
+
+    it('should handle array values', () => {
+      const headers: Record<string, string[]> = {};
+
+      setResponseHeader(headers, 'Set-Cookie', ['a=1', 'b=2']);
+
+      expect(headers['Set-Cookie']).toEqual(['a=1', 'b=2']);
+    });
+
+    it('should replace multiple headers with different cases', () => {
+      const headers: Record<string, string[]> = {
+        'ACCESS-CONTROL-ALLOW-ORIGIN': ['*'],
+        'access-control-allow-origin': ['http://localhost'],
+      };
+
+      setResponseHeader(headers, 'Access-Control-Allow-Origin', 'http://example.com');
+
+      expect(headers['Access-Control-Allow-Origin']).toEqual(['http://example.com']);
+      expect(Object.keys(headers)).toHaveLength(1);
+    });
+  });
+
+  describe('hasResponseHeader', () => {
+    it('should return true for existing header', () => {
+      const headers = { 'Content-Type': ['application/json'] };
+
+      expect(hasResponseHeader(headers, 'Content-Type')).toBe(true);
+    });
+
+    it('should return true for existing header with different case', () => {
+      const headers = { 'content-type': ['application/json'] };
+
+      expect(hasResponseHeader(headers, 'Content-Type')).toBe(true);
+    });
+
+    it('should return false for non-existing header', () => {
+      const headers = { 'Content-Type': ['application/json'] };
+
+      expect(hasResponseHeader(headers, 'Authorization')).toBe(false);
+    });
+  });
+
+  describe('getResponseHeader', () => {
+    it('should get header value', () => {
+      const headers = { 'Content-Type': ['application/json'] };
+
+      expect(getResponseHeader(headers, 'Content-Type')).toEqual(['application/json']);
+    });
+
+    it('should get header value with different case', () => {
+      const headers = { 'content-type': ['application/json'] };
+
+      expect(getResponseHeader(headers, 'Content-Type')).toEqual(['application/json']);
+    });
+
+    it('should return undefined for non-existing header', () => {
+      const headers = { 'Content-Type': ['application/json'] };
+
+      expect(getResponseHeader(headers, 'Authorization')).toBeUndefined();
+    });
+  });
+
+  describe('deleteResponseHeader', () => {
+    it('should delete existing header', () => {
+      const headers: Record<string, string[]> = { 'Content-Type': ['application/json'] };
+
+      const result = deleteResponseHeader(headers, 'Content-Type');
+
+      expect(result).toBe(true);
+      expect(headers['Content-Type']).toBeUndefined();
+    });
+
+    it('should delete header with different case', () => {
+      const headers: Record<string, string[]> = { 'content-type': ['application/json'] };
+
+      const result = deleteResponseHeader(headers, 'Content-Type');
+
+      expect(result).toBe(true);
+      expect(headers['content-type']).toBeUndefined();
+    });
+
+    it('should return false for non-existing header', () => {
+      const headers: Record<string, string[]> = { 'Content-Type': ['application/json'] };
+
+      const result = deleteResponseHeader(headers, 'Authorization');
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/apps/desktop/src/main/utils/http-headers.ts

@@ -0,0 +1,61 @@
+/**
+ * HTTP headers utilities for Electron webRequest
+ *
+ * Electron's webRequest responseHeaders is a plain JS object where keys are case-sensitive,
+ * but HTTP headers are case-insensitive per spec. These utilities handle this mismatch.
+ */
+
+type ElectronResponseHeaders = Record<string, string[]>;
+
+/**
+ * Set a header value, replacing any existing header with the same name (case-insensitive)
+ */
+export function setResponseHeader(
+  headers: ElectronResponseHeaders,
+  name: string,
+  value: string | string[],
+): void {
+  // Delete any existing header with same name (case-insensitive)
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === name.toLowerCase()) {
+      delete headers[key];
+    }
+  }
+  headers[name] = Array.isArray(value) ? value : [value];
+}
+
+/**
+ * Check if a header exists (case-insensitive)
+ */
+export function hasResponseHeader(headers: ElectronResponseHeaders, name: string): boolean {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+}
+
+/**
+ * Get a header value (case-insensitive)
+ */
+export function getResponseHeader(
+  headers: ElectronResponseHeaders,
+  name: string,
+): string[] | undefined {
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === name.toLowerCase()) {
+      return headers[key];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Delete a header (case-insensitive)
+ */
+export function deleteResponseHeader(headers: ElectronResponseHeaders, name: string): boolean {
+  let deleted = false;
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === name.toLowerCase()) {
+      delete headers[key];
+      deleted = true;
+    }
+  }
+  return deleted;
+}

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

@@ -1,13 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type { IpcContext } from '../base';
-import {
-  IpcMethod,
-  IpcServerMethod,
-  IpcService,
-  getIpcContext,
-  getServerMethodMetadata,
-} from '../base';
+import { IpcMethod, IpcService, getIpcContext } from '../base';
 
 const { ipcMainHandleMock } = vi.hoisted(() => ({
   ipcMainHandleMock: vi.fn(),
@@ -73,19 +67,4 @@ describe('ipc service base', () => {
     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');
-  });
 });

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

@@ -10,7 +10,6 @@ export interface IpcContext {
 
 // Metadata storage for decorated methods
 const methodMetadata = new WeakMap<any, Map<string, string>>();
-const serverMethodMetadata = new WeakMap<any, Map<string, string>>();
 const ipcContextStorage = new AsyncLocalStorage<IpcContext>();
 
 // Decorator for IPC methods
@@ -29,21 +28,6 @@ export function IpcMethod() {
   };
 }
 
-export function IpcServerMethod(channelName?: string) {
-  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    const { constructor } = target;
-
-    if (!serverMethodMetadata.has(constructor)) {
-      serverMethodMetadata.set(constructor, new Map());
-    }
-
-    const methods = serverMethodMetadata.get(constructor)!;
-    methods.set(propertyKey, channelName || propertyKey);
-
-    return descriptor;
-  };
-}
-
 // Handler registry for IPC methods
 export class IpcHandler {
   private static instance: IpcHandler;
@@ -157,10 +141,6 @@ export type CreateServicesResult<T extends readonly IpcServiceConstructor[]> = {
   [K in T[number] as K['groupName']]: InstanceType<K>;
 };
 
-export function getServerMethodMetadata(target: IpcServiceConstructor) {
-  return serverMethodMetadata.get(target);
-}
-
 export function getIpcContext() {
   return ipcContextStorage.getStore();
 }

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

@@ -1,11 +1,3 @@
 export type { CreateServicesResult, IpcContext, IpcServiceConstructor } from './base';
-export {
-  createServices,
-  getIpcContext,
-  getServerMethodMetadata,
-  IpcMethod,
-  IpcServerMethod,
-  IpcService,
-  runWithIpcContext,
-} from './base';
+export { createServices, getIpcContext, IpcMethod, IpcService, runWithIpcContext } from './base';
 export type { ExtractServiceMethods, MergeIpcService } from './utility';

package/changelog/v1.json

@@ -1,4 +1,9 @@
 [
+  {
+    "children": {},
+    "date": "2026-01-08",
+    "version": "2.0.0-next.243"
+  },
   {
     "children": {},
     "date": "2026-01-08",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.242",
+  "version": "2.0.0-next.243",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/src/features/ChatInput/InputEditor/Placeholder.tsx

@@ -1,7 +1,7 @@
 import { KeyEnum } from '@lobechat/types';
 import { Flexbox, Hotkey, combineKeys } from '@lobehub/ui';
 import { memo } from 'react';
-import { Trans } from 'react-i18next';
+import { Trans, useTranslation } from 'react-i18next';
 
 import { useUserStore } from '@/store/user';
 import { preferenceSelectors } from '@/store/user/selectors';
@@ -12,6 +12,9 @@ const Placeholder = memo(() => {
     ? KeyEnum.Enter
     : combineKeys([KeyEnum.Mod, KeyEnum.Enter]);
 
+  // Don't remove this line for i18n reactivity
+  void useTranslation('chat');
+
   return (
     <Flexbox align={'center'} as={'span'} gap={4} horizontal wrap={'wrap'}>
       <Trans

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

@@ -1,33 +0,0 @@
-import { CreateFileParams } from '@lobechat/electron-server-ipc';
-
-import FileService from '@/services/fileSrv';
-
-import { ControllerModule, IpcServerMethod } from './index';
-
-export default class UploadFileServerCtr extends ControllerModule {
-  static override readonly groupName = 'upload';
-
-  private get fileService() {
-    return this.app.getService(FileService);
-  }
-
-  @IpcServerMethod()
-  async getFileUrlById(id: string) {
-    return this.fileService.getFilePath(id);
-  }
-
-  @IpcServerMethod()
-  async getFileHTTPURL(path: string) {
-    return this.fileService.getFileHTTPURL(path);
-  }
-
-  @IpcServerMethod()
-  async deleteFiles(paths: string[]) {
-    return this.fileService.deleteFiles(paths);
-  }
-
-  @IpcServerMethod()
-  async createFile(params: CreateFileParams) {
-    return this.fileService.uploadFile(params);
-  }
-}

package/apps/desktop/src/main/controllers/__tests__/UploadFileServerCtr.test.ts

@@ -1,55 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { App } from '@/core/App';
-
-import UploadFileServerCtr from '../UploadFileServerCtr';
-
-vi.mock('@/services/fileSrv', () => ({
-  default: class MockFileService {},
-}));
-
-const mockFileService = {
-  getFileHTTPURL: vi.fn(),
-  getFilePath: vi.fn(),
-  deleteFiles: vi.fn(),
-  uploadFile: vi.fn(),
-};
-
-const mockApp = {
-  getService: vi.fn(() => mockFileService),
-} as unknown as App;
-
-describe('UploadFileServerCtr', () => {
-  let controller: UploadFileServerCtr;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    controller = new UploadFileServerCtr(mockApp);
-  });
-
-  it('gets file path by id', async () => {
-    mockFileService.getFilePath.mockResolvedValue('path');
-    await expect(controller.getFileUrlById('id')).resolves.toBe('path');
-    expect(mockFileService.getFilePath).toHaveBeenCalledWith('id');
-  });
-
-  it('gets HTTP URL', async () => {
-    mockFileService.getFileHTTPURL.mockResolvedValue('url');
-    await expect(controller.getFileHTTPURL('/path')).resolves.toBe('url');
-    expect(mockFileService.getFileHTTPURL).toHaveBeenCalledWith('/path');
-  });
-
-  it('deletes files', async () => {
-    mockFileService.deleteFiles.mockResolvedValue(undefined);
-    await controller.deleteFiles(['a']);
-    expect(mockFileService.deleteFiles).toHaveBeenCalledWith(['a']);
-  });
-
-  it('creates files via upload service', async () => {
-    const params = { filename: 'file' } as any;
-    mockFileService.uploadFile.mockResolvedValue({ success: true });
-
-    await expect(controller.createFile(params)).resolves.toEqual({ success: true });
-    expect(mockFileService.uploadFile).toHaveBeenCalledWith(params);
-  });
-});