@lobehub/lobehub 2.0.0-next.141 → 2.0.0-next.142

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 2.0.0-next.142](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.141...v2.0.0-next.142)
+
+<sup>Released on **2025-12-01**</sup>
+
+#### 🐛 Bug Fixes
+
+- **misc**: Remove internal apiMode param from chat completion API requests.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's fixed
+
+- **misc**: Remove internal apiMode param from chat completion API requests, closes [#10539](https://github.com/lobehub/lobe-chat/issues/10539) ([9498cc6](https://github.com/lobehub/lobe-chat/commit/9498cc6))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.141](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.140...v2.0.0-next.141)
 
 <sup>Released on **2025-12-01**</sup>

package/Dockerfile

@@ -231,6 +231,8 @@ ENV \
     GITHUB_TOKEN="" GITHUB_MODEL_LIST="" \
     # Google
     GOOGLE_API_KEY="" GOOGLE_MODEL_LIST="" GOOGLE_PROXY_URL="" \
+    # Vertex AI
+    VERTEXAI_CREDENTIALS="" VERTEXAI_PROJECT="" VERTEXAI_LOCATION="" VERTEXAI_MODEL_LIST="" \
     # Groq
     GROQ_API_KEY="" GROQ_MODEL_LIST="" GROQ_PROXY_URL="" \
     # Higress

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

@@ -0,0 +1,286 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import McpInstallController from '../McpInstallCtr';
+
+// Mock logger
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+// Mock browserManager
+const mockBrowserManager = {
+  broadcastToWindow: vi.fn(),
+};
+
+const mockApp = {
+  browserManager: mockBrowserManager,
+} as unknown as App;
+
+describe('McpInstallController', () => {
+  let controller: McpInstallController;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    controller = new McpInstallController(mockApp);
+  });
+
+  describe('handleInstallRequest', () => {
+    const validStdioSchema = {
+      identifier: 'test-plugin',
+      name: 'Test Plugin',
+      author: 'Test Author',
+      description: 'A test plugin',
+      version: '1.0.0',
+      config: {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', 'test-mcp-server'],
+      },
+    };
+
+    const validHttpSchema = {
+      identifier: 'test-http-plugin',
+      name: 'Test HTTP Plugin',
+      author: 'Test Author',
+      description: 'A test HTTP plugin',
+      version: '1.0.0',
+      config: {
+        type: 'http',
+        url: 'https://api.example.com/mcp',
+      },
+    };
+
+    it('should return false when id is missing', async () => {
+      const result = await controller.handleInstallRequest({
+        id: '',
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should return false when schema is missing for third-party marketplace', async () => {
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should succeed for official market without schema', async () => {
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'lobehub',
+      });
+
+      expect(result).toBe(true);
+      expect(mockBrowserManager.broadcastToWindow).toHaveBeenCalledWith(
+        'chat',
+        'mcpInstallRequest',
+        {
+          marketId: 'lobehub',
+          pluginId: 'test-plugin',
+          schema: undefined,
+        },
+      );
+    });
+
+    it('should return false when schema is invalid JSON', async () => {
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: 'invalid json {',
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should return false when schema structure is invalid', async () => {
+      const invalidSchema = {
+        identifier: 'test-plugin',
+        // missing required fields
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(invalidSchema),
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should return false when schema identifier does not match id', async () => {
+      const schema = { ...validStdioSchema, identifier: 'different-id' };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(schema),
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should succeed with valid stdio schema', async () => {
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(validStdioSchema),
+      });
+
+      expect(result).toBe(true);
+      expect(mockBrowserManager.broadcastToWindow).toHaveBeenCalledWith(
+        'chat',
+        'mcpInstallRequest',
+        {
+          marketId: 'third-party',
+          pluginId: 'test-plugin',
+          schema: validStdioSchema,
+        },
+      );
+    });
+
+    it('should succeed with valid http schema', async () => {
+      const result = await controller.handleInstallRequest({
+        id: 'test-http-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(validHttpSchema),
+      });
+
+      expect(result).toBe(true);
+      expect(mockBrowserManager.broadcastToWindow).toHaveBeenCalledWith(
+        'chat',
+        'mcpInstallRequest',
+        {
+          marketId: 'third-party',
+          pluginId: 'test-http-plugin',
+          schema: validHttpSchema,
+        },
+      );
+    });
+
+    it('should return false when http schema has invalid URL', async () => {
+      const invalidHttpSchema = {
+        ...validHttpSchema,
+        config: {
+          type: 'http',
+          url: 'not-a-valid-url',
+        },
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-http-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(invalidHttpSchema),
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should return false when config type is unknown', async () => {
+      const unknownTypeSchema = {
+        ...validStdioSchema,
+        config: {
+          type: 'unknown',
+        },
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(unknownTypeSchema),
+      });
+
+      expect(result).toBe(false);
+      expect(mockBrowserManager.broadcastToWindow).not.toHaveBeenCalled();
+    });
+
+    it('should return false when browserManager is not available', async () => {
+      const controllerWithoutBrowserManager = new McpInstallController({} as App);
+
+      const result = await controllerWithoutBrowserManager.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'lobehub',
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle schema with optional fields', async () => {
+      const schemaWithOptionalFields = {
+        ...validStdioSchema,
+        homepage: 'https://example.com',
+        icon: 'https://example.com/icon.png',
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(schemaWithOptionalFields),
+      });
+
+      expect(result).toBe(true);
+      expect(mockBrowserManager.broadcastToWindow).toHaveBeenCalledWith(
+        'chat',
+        'mcpInstallRequest',
+        expect.objectContaining({
+          schema: schemaWithOptionalFields,
+        }),
+      );
+    });
+
+    it('should return false when stdio config missing command', async () => {
+      const invalidStdioSchema = {
+        ...validStdioSchema,
+        config: {
+          type: 'stdio',
+          // missing command
+        },
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(invalidStdioSchema),
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should handle schema with env configuration', async () => {
+      const schemaWithEnv = {
+        ...validStdioSchema,
+        config: {
+          type: 'stdio',
+          command: 'npx',
+          args: ['-y', 'test-mcp-server'],
+          env: {
+            API_KEY: 'test-key',
+          },
+        },
+      };
+
+      const result = await controller.handleInstallRequest({
+        id: 'test-plugin',
+        marketId: 'third-party',
+        schema: JSON.stringify(schemaWithEnv),
+      });
+
+      expect(result).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,347 @@
+import { ShowDesktopNotificationParams } from '@lobechat/electron-client-ipc';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { App } from '@/core/App';
+
+import NotificationCtr from '../NotificationCtr';
+
+// Mock logger
+vi.mock('@/utils/logger', () => ({
+  createLogger: () => ({
+    debug: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+// Mock electron
+vi.mock('electron', () => {
+  const mockNotificationInstance = {
+    on: vi.fn(),
+    show: vi.fn(),
+  };
+  const MockNotification = vi.fn(() => mockNotificationInstance) as any;
+  MockNotification.isSupported = vi.fn(() => true);
+
+  return {
+    Notification: MockNotification,
+    app: {
+      setAppUserModelId: vi.fn(),
+    },
+  };
+});
+
+// Mock electron-is
+vi.mock('electron-is', () => ({
+  macOS: vi.fn(() => false),
+  windows: vi.fn(() => false),
+}));
+
+// Mock browserManager
+const mockBrowserWindow = {
+  focus: vi.fn(),
+  isDestroyed: vi.fn(() => false),
+  isFocused: vi.fn(() => true),
+  isMinimized: vi.fn(() => false),
+  isVisible: vi.fn(() => true),
+};
+
+const mockMainWindow = {
+  browserWindow: mockBrowserWindow,
+  show: vi.fn(),
+};
+
+const mockBrowserManager = {
+  getMainWindow: vi.fn(() => mockMainWindow),
+};
+
+const mockApp = {
+  browserManager: mockBrowserManager,
+} as unknown as App;
+
+describe('NotificationCtr', () => {
+  let controller: NotificationCtr;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    controller = new NotificationCtr(mockApp);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('afterAppReady', () => {
+    it('should setup notifications when supported', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+
+      controller.afterAppReady();
+
+      expect(Notification.isSupported).toHaveBeenCalled();
+    });
+
+    it('should not setup when notifications are not supported', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(false);
+
+      controller.afterAppReady();
+
+      expect(Notification.isSupported).toHaveBeenCalled();
+    });
+
+    it('should set app user model ID on Windows', async () => {
+      const { windows } = await import('electron-is');
+      const { app, Notification } = await import('electron');
+      vi.mocked(windows).mockReturnValue(true);
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+
+      controller.afterAppReady();
+
+      expect(app.setAppUserModelId).toHaveBeenCalledWith('com.lobehub.chat');
+
+      vi.mocked(windows).mockReturnValue(false);
+    });
+
+    it('should handle macOS platform', async () => {
+      const { macOS } = await import('electron-is');
+      const { Notification } = await import('electron');
+      vi.mocked(macOS).mockReturnValue(true);
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+
+      // Should not throw
+      expect(() => controller.afterAppReady()).not.toThrow();
+
+      vi.mocked(macOS).mockReturnValue(false);
+    });
+  });
+
+  describe('showDesktopNotification', () => {
+    const params: ShowDesktopNotificationParams = {
+      body: 'Test body',
+      title: 'Test title',
+    };
+
+    it('should return error when notifications are not supported', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(false);
+
+      const result = await controller.showDesktopNotification(params);
+
+      expect(result).toEqual({
+        error: 'Desktop notifications not supported',
+        success: false,
+      });
+    });
+
+    it('should skip notification when window is visible and focused', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(true);
+      mockBrowserWindow.isMinimized.mockReturnValue(false);
+
+      const result = await controller.showDesktopNotification(params);
+
+      expect(result).toEqual({
+        reason: 'Window is visible',
+        skipped: true,
+        success: true,
+      });
+    });
+
+    it('should show notification when window is hidden', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+
+      const promise = controller.showDesktopNotification(params);
+      vi.advanceTimersByTime(100);
+      const result = await promise;
+
+      expect(Notification).toHaveBeenCalledWith({
+        body: 'Test body',
+        hasReply: false,
+        silent: false,
+        timeoutType: 'default',
+        title: 'Test title',
+        urgency: 'normal',
+      });
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should show notification when window is minimized', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(true);
+      mockBrowserWindow.isMinimized.mockReturnValue(true);
+
+      const promise = controller.showDesktopNotification(params);
+      vi.advanceTimersByTime(100);
+      const result = await promise;
+
+      expect(Notification).toHaveBeenCalled();
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should show notification when window is not focused', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(false);
+      mockBrowserWindow.isMinimized.mockReturnValue(false);
+
+      const promise = controller.showDesktopNotification(params);
+      vi.advanceTimersByTime(100);
+      const result = await promise;
+
+      expect(Notification).toHaveBeenCalled();
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should pass silent option to notification', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+
+      const paramsWithSilent: ShowDesktopNotificationParams = {
+        ...params,
+        silent: true,
+      };
+
+      const promise = controller.showDesktopNotification(paramsWithSilent);
+      vi.advanceTimersByTime(100);
+      await promise;
+
+      expect(Notification).toHaveBeenCalledWith(
+        expect.objectContaining({
+          silent: true,
+        }),
+      );
+    });
+
+    it('should register click handler to show main window', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+
+      // Get the mock instance that will be created
+      const mockInstance = { on: vi.fn(), show: vi.fn() };
+      vi.mocked(Notification).mockReturnValue(mockInstance as any);
+
+      const promise = controller.showDesktopNotification(params);
+      vi.advanceTimersByTime(100);
+      await promise;
+
+      // Find the click handler
+      const clickHandler = mockInstance.on.mock.calls.find((call) => call[0] === 'click')?.[1];
+
+      expect(clickHandler).toBeDefined();
+
+      // Simulate click
+      clickHandler();
+
+      expect(mockMainWindow.show).toHaveBeenCalled();
+      expect(mockBrowserWindow.focus).toHaveBeenCalled();
+    });
+
+    it('should handle notification error', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+      vi.mocked(Notification).mockImplementationOnce(() => {
+        throw new Error('Notification error');
+      });
+
+      const result = await controller.showDesktopNotification(params);
+
+      expect(result).toEqual({
+        error: 'Notification error',
+        success: false,
+      });
+    });
+
+    it('should handle unknown error type', async () => {
+      const { Notification } = await import('electron');
+      vi.mocked(Notification.isSupported).mockReturnValue(true);
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+      vi.mocked(Notification).mockImplementationOnce(() => {
+        throw 'string error';
+      });
+
+      const result = await controller.showDesktopNotification(params);
+
+      expect(result).toEqual({
+        error: 'Unknown error',
+        success: false,
+      });
+    });
+  });
+
+  describe('isMainWindowHidden', () => {
+    it('should return false when window is visible and focused', () => {
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(true);
+      mockBrowserWindow.isMinimized.mockReturnValue(false);
+      mockBrowserWindow.isDestroyed.mockReturnValue(false);
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when window is not visible', () => {
+      mockBrowserWindow.isVisible.mockReturnValue(false);
+      mockBrowserWindow.isFocused.mockReturnValue(true);
+      mockBrowserWindow.isMinimized.mockReturnValue(false);
+      mockBrowserWindow.isDestroyed.mockReturnValue(false);
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true when window is minimized', () => {
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(true);
+      mockBrowserWindow.isMinimized.mockReturnValue(true);
+      mockBrowserWindow.isDestroyed.mockReturnValue(false);
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true when window is not focused', () => {
+      mockBrowserWindow.isVisible.mockReturnValue(true);
+      mockBrowserWindow.isFocused.mockReturnValue(false);
+      mockBrowserWindow.isMinimized.mockReturnValue(false);
+      mockBrowserWindow.isDestroyed.mockReturnValue(false);
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true when window is destroyed', () => {
+      mockBrowserWindow.isDestroyed.mockReturnValue(true);
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true on error', () => {
+      mockBrowserManager.getMainWindow.mockImplementationOnce(() => {
+        throw new Error('Window not available');
+      });
+
+      const result = controller.isMainWindowHidden();
+
+      expect(result).toBe(true);
+    });
+  });
+});