@lobehub/chat 1.77.2 → 1.77.4

package/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 # Changelog
 
+### [Version 1.77.4](https://github.com/lobehub/lobe-chat/compare/v1.77.3...v1.77.4)
+
+<sup>Released on **2025-03-31**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Refactor db core.
+
+#### 💄 Styles
+
+- **misc**: Update branding.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Refactor db core, closes [#7245](https://github.com/lobehub/lobe-chat/issues/7245) ([5c71db6](https://github.com/lobehub/lobe-chat/commit/5c71db6))
+
+#### Styles
+
+- **misc**: Update branding, closes [#7224](https://github.com/lobehub/lobe-chat/issues/7224) ([481cab0](https://github.com/lobehub/lobe-chat/commit/481cab0))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
+### [Version 1.77.3](https://github.com/lobehub/lobe-chat/compare/v1.77.2...v1.77.3)
+
+<sup>Released on **2025-03-29**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Move general db models to database folder.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Move general db models to database folder, closes [#7222](https://github.com/lobehub/lobe-chat/issues/7222) ([f831d86](https://github.com/lobehub/lobe-chat/commit/f831d86))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.77.2](https://github.com/lobehub/lobe-chat/compare/v1.77.1...v1.77.2)
 
 <sup>Released on **2025-03-29**</sup>

package/changelog/v1.json

@@ -1,4 +1,22 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Update branding."
+      ]
+    },
+    "date": "2025-03-31",
+    "version": "1.77.4"
+  },
+  {
+    "children": {
+      "improvements": [
+        "Move general db models to database folder."
+      ]
+    },
+    "date": "2025-03-29",
+    "version": "1.77.3"
+  },
   {
     "children": {
       "fixes": [

package/docs/self-hosting/environment-variables/model-provider.mdx

@@ -578,7 +578,7 @@ If you need to use Azure OpenAI to provide model services, you can refer to the
 - Type: Optional
 - Description: Used to control the model list, use `+` to add a model, use `-` to hide a model, use `model_name->deploymentName=display_name` to customize the display name of a model, separated by commas. Definition syntax rules see [model-list][model-list]
 - Default: `-`
-- Example: `-all,+deepseek-r1->deepseek-r1-250120,+deepseek-v3->deepseek-v3-241226,+doubao-1.5-pro-256k->doubao-1-5-pro-256k-250115,+doubao-1.5-pro-32k->doubao-1-5-pro-32k-250115,+doubao-1.5-lite-32k->doubao-1-5-lite-32k-250115`
+- Example: `-all,+deepseek-r1->deepseek-r1-250120,+deepseek-v3->deepseek-v3-250324,+doubao-1.5-pro-256k->doubao-1-5-pro-256k-250115,+doubao-1.5-pro-32k->doubao-1-5-pro-32k-250115,+doubao-1.5-lite-32k->doubao-1-5-lite-32k-250115`
 
 ### `VOLCENGINE_PROXY_URL`
 

package/docs/self-hosting/environment-variables/model-provider.zh-CN.mdx

@@ -577,7 +577,7 @@ LobeChat 在部署时提供了丰富的模型服务商相关的环境变量，
 - 类型：可选
 - 描述：用来控制模型列表，使用 `+` 增加一个模型，使用 `-` 来隐藏一个模型，使用 `模型名->部署名=展示名<扩展配置>` 来自定义模型的展示名，用英文逗号隔开。模型定义语法规则见 [模型列表][model-list]
 - 默认值：`-`
-- 示例：`-all,+deepseek-r1->deepseek-r1-250120,+deepseek-v3->deepseek-v3-241226,+doubao-1.5-pro-256k->doubao-1-5-pro-256k-250115,+doubao-1.5-pro-32k->doubao-1-5-pro-32k-250115,+doubao-1.5-lite-32k->doubao-1-5-lite-32k-250115`
+- 示例：`-all,+deepseek-r1->deepseek-r1-250120,+deepseek-v3->deepseek-v3-250324,+doubao-1.5-pro-256k->doubao-1-5-pro-256k-250115,+doubao-1.5-pro-32k->doubao-1-5-pro-32k-250115,+doubao-1.5-lite-32k->doubao-1-5-lite-32k-250115`
 
 ### `VOLCENGINE_PROXY_URL`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.77.2",
+  "version": "1.77.4",
   "description": "Lobe Chat - an open-source, high-performance chatbot 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",
@@ -136,7 +136,7 @@
     "@lobehub/icons": "^1.73.1",
     "@lobehub/tts": "^1.28.0",
     "@lobehub/ui": "^1.169.2",
-    "@neondatabase/serverless": "^0.10.4",
+    "@neondatabase/serverless": "^1.0.0",
     "@next/third-parties": "15.2.3",
     "@react-spring/web": "^9.7.5",
     "@sentry/nextjs": "^7.120.2",
@@ -182,7 +182,7 @@
     "langfuse": "3.29.1",
     "langfuse-core": "3.29.1",
     "lodash-es": "^4.17.21",
-    "lucide-react": "^0.483.0",
+    "lucide-react": "^0.485.0",
     "mammoth": "^1.9.0",
     "mdast-util-to-markdown": "^2.1.2",
     "modern-screenshot": "^4.5.5",

package/packages/electron-server-ipc/README.md

@@ -0,0 +1,54 @@
+# @lobechat/electron-server-ipc
+
+LobeHub 的 Electron 应用与服务端之间的 IPC（进程间通信）模块，提供可靠的跨进程通信能力。
+
+## 📝 简介
+
+`@lobechat/electron-server-ipc` 是 LobeHub 桌面应用的核心组件，负责处理 Electron 进程与 nextjs 服务端之间的通信。它提供了一套简单而健壮的 API，用于在不同进程间传递数据和执行远程方法调用。
+
+## 🛠️ 核心功能
+
+- **可靠的 IPC 通信**: 基于 Socket 的通信机制，确保跨进程通信的稳定性和可靠性
+- **自动重连机制**: 客户端具备断线重连功能，提高应用稳定性
+- **类型安全**: 使用 TypeScript 提供完整的类型定义，确保 API 调用的类型安全
+- **跨平台支持**: 同时支持 Windows、macOS 和 Linux 平台
+
+## 🧩 核心组件
+
+### IPC 服务端 (ElectronIPCServer)
+
+负责监听客户端请求并响应，通常运行在 Electron 的主进程中：
+
+```typescript
+import { ElectronIPCEventHandler, ElectronIPCServer } from '@lobechat/electron-server-ipc';
+
+// 定义处理函数
+const eventHandler: ElectronIPCEventHandler = {
+  getDatabasePath: async () => {
+    return '/path/to/database';
+  },
+  // 其他处理函数...
+};
+
+// 创建并启动服务器
+const server = new ElectronIPCServer(eventHandler);
+server.start();
+```
+
+### IPC 客户端 (ElectronIpcClient)
+
+负责连接到服务端并发送请求，通常在服务端（如 Next.js 服务）中使用：
+
+```typescript
+import { ElectronIPCMethods, ElectronIpcClient } from '@lobechat/electron-server-ipc';
+
+// 创建客户端
+const client = new ElectronIpcClient();
+
+// 发送请求
+const dbPath = await client.sendRequest(ElectronIPCMethods.getDatabasePath);
+```
+
+## 📌 说明
+
+这是 LobeHub 的内部模块 (`"private": true`)，专为 LobeHub 桌面应用设计，不作为独立包发布。

package/packages/electron-server-ipc/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@lobechat/electron-server-ipc",
+  "version": "1.0.0",
+  "private": true,
+  "main": "src/index.ts",
+  "types": "src/index.ts"
+}

package/packages/electron-server-ipc/src/const.ts

@@ -0,0 +1,5 @@
+export const SOCK_FILE = 'lobehub-electron-ipc.sock';
+
+export const SOCK_INFO_FILE = 'lobehub-electron-ipc-info.json';
+
+export const WINDOW_PIPE_FILE = '\\\\.\\pipe\\lobehub-electron-ipc';

package/packages/electron-server-ipc/src/index.ts

@@ -0,0 +1,3 @@
+export * from './ipcClient';
+export * from './ipcServer';
+export * from './types';

package/packages/electron-server-ipc/src/ipcClient.test.ts

@@ -0,0 +1,211 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ElectronIpcClient } from './ipcClient';
+import { ElectronIPCMethods } from './types';
+
+// Mock node modules
+vi.mock('node:fs');
+vi.mock('node:net');
+vi.mock('node:os');
+vi.mock('node:path');
+
+describe('ElectronIpcClient', () => {
+  // Mock data
+  const mockTempDir = '/mock/temp/dir';
+  const mockSocketInfoPath = '/mock/temp/dir/lobehub-electron-ipc-info.json';
+  const mockSocketInfo = { socketPath: '/mock/socket/path' };
+
+  // Mock socket
+  const mockSocket = {
+    on: vi.fn(),
+    write: vi.fn(),
+    end: vi.fn(),
+  };
+
+  beforeEach(() => {
+    // Use fake timers
+    vi.useFakeTimers();
+
+    // Reset all mocks
+    vi.resetAllMocks();
+
+    // Setup common mocks
+    vi.mocked(os.tmpdir).mockReturnValue(mockTempDir);
+    vi.mocked(path.join).mockImplementation((...args) => args.join('/'));
+    vi.mocked(net.createConnection).mockReturnValue(mockSocket as unknown as net.Socket);
+
+    // Mock console methods
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe('initialization', () => {
+    it('should initialize with socket path from info file if it exists', () => {
+      // Setup
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockSocketInfo));
+
+      // Execute
+      new ElectronIpcClient();
+
+      // Verify
+      expect(fs.existsSync).toHaveBeenCalledWith(mockSocketInfoPath);
+      expect(fs.readFileSync).toHaveBeenCalledWith(mockSocketInfoPath, 'utf8');
+    });
+
+    it('should initialize with default socket path if info file does not exist', () => {
+      // Setup
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      // Execute
+      new ElectronIpcClient();
+
+      // Verify
+      expect(fs.existsSync).toHaveBeenCalledWith(mockSocketInfoPath);
+      expect(fs.readFileSync).not.toHaveBeenCalled();
+
+      // Test platform-specific behavior
+      const originalPlatform = process.platform;
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      new ElectronIpcClient();
+      Object.defineProperty(process, 'platform', { value: originalPlatform });
+    });
+
+    it('should handle initialization errors gracefully', () => {
+      // Setup - Mock the error
+      vi.mocked(fs.existsSync).mockImplementation(() => {
+        throw new Error('Mock file system error');
+      });
+
+      // Execute
+      new ElectronIpcClient();
+
+      // Verify
+      expect(console.error).toHaveBeenCalledWith(
+        'Failed to initialize IPC client:',
+        expect.objectContaining({ message: 'Mock file system error' }),
+      );
+    });
+  });
+
+  describe('connection and request handling', () => {
+    let client: ElectronIpcClient;
+
+    beforeEach(() => {
+      // Setup a client with a known socket path
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockSocketInfo));
+      client = new ElectronIpcClient();
+
+      // Reset socket mocks for each test
+      mockSocket.on.mockReset();
+      mockSocket.write.mockReset();
+
+      // Default implementation for socket.on
+      mockSocket.on.mockImplementation((event, callback) => {
+        return mockSocket;
+      });
+
+      // Default implementation for socket.write
+      mockSocket.write.mockImplementation((data, callback) => {
+        if (callback) callback();
+        return true;
+      });
+    });
+
+    it('should handle connection errors', async () => {
+      // Start request - but don't await it yet
+      const requestPromise = client.sendRequest(ElectronIPCMethods.getDatabasePath);
+
+      // Find the error event handler
+      const errorCallArgs = mockSocket.on.mock.calls.find((call) => call[0] === 'error');
+      if (errorCallArgs && typeof errorCallArgs[1] === 'function') {
+        const errorHandler = errorCallArgs[1];
+
+        // Trigger the error handler
+        errorHandler(new Error('Connection error'));
+      }
+
+      // Now await the promise
+      await expect(requestPromise).rejects.toThrow('Connection error');
+    });
+
+    it('should handle write errors', async () => {
+      // Setup connection callback
+      let connectionCallback: Function | undefined;
+      vi.mocked(net.createConnection).mockImplementation((path, callback) => {
+        connectionCallback = callback as Function;
+        return mockSocket as unknown as net.Socket;
+      });
+
+      // Setup write to fail
+      mockSocket.write.mockImplementation((data, callback) => {
+        if (callback) callback(new Error('Write error'));
+        return true;
+      });
+
+      // Start request
+      const requestPromise = client.sendRequest(ElectronIPCMethods.getDatabasePath);
+
+      // Simulate connection established
+      if (connectionCallback) connectionCallback();
+
+      // Now await the promise
+      await expect(requestPromise).rejects.toThrow('Write error');
+    });
+  });
+
+  describe('close method', () => {
+    let client: ElectronIpcClient;
+
+    beforeEach(() => {
+      // Setup a client with a known socket path
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockSocketInfo));
+      client = new ElectronIpcClient();
+
+      // Setup socket.on
+      mockSocket.on.mockImplementation((event, callback) => {
+        return mockSocket;
+      });
+    });
+
+    it('should close the socket connection', async () => {
+      // Setup connection callback
+      let connectionCallback: Function | undefined;
+      vi.mocked(net.createConnection).mockImplementation((path, callback) => {
+        connectionCallback = callback as Function;
+        return mockSocket as unknown as net.Socket;
+      });
+
+      // Start a request to establish connection (but don't wait for it)
+      const requestPromise = client.sendRequest(ElectronIPCMethods.getDatabasePath).catch(() => {}); // Ignore any errors
+
+      // Simulate connection
+      if (connectionCallback) connectionCallback();
+
+      // Close the connection
+      client.close();
+
+      // Verify
+      expect(mockSocket.end).toHaveBeenCalled();
+    });
+
+    it('should handle close when not connected', () => {
+      // Close without connecting
+      client.close();
+
+      // Verify no errors
+      expect(mockSocket.end).not.toHaveBeenCalled();
+    });
+  });
+});

package/packages/electron-server-ipc/src/ipcClient.ts

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+
+import { SOCK_FILE, SOCK_INFO_FILE, WINDOW_PIPE_FILE } from './const';
+import { IElectronIPCMethods } from './types';
+
+export class ElectronIpcClient {
+  private socketPath: string | null = null;
+  private connected: boolean = false;
+  private socket: net.Socket | null = null;
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  private requestQueue: Map<string, { reject: Function; resolve: Function }> = new Map();
+  // eslint-disable-next-line no-undef
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+  private connectionAttempts: number = 0;
+  private maxConnectionAttempts: number = 5;
+
+  constructor() {
+    this.initialize();
+  }
+
+  // 初始化客户端
+  private initialize() {
+    try {
+      // 从临时文件读取套接字路径
+      const tempDir = os.tmpdir();
+      const socketInfoPath = path.join(tempDir, SOCK_INFO_FILE);
+
+      if (fs.existsSync(socketInfoPath)) {
+        const socketInfo = JSON.parse(fs.readFileSync(socketInfoPath, 'utf8'));
+        this.socketPath = socketInfo.socketPath;
+      } else {
+        // 如果找不到套接字信息，使用默认路径
+        this.socketPath =
+          process.platform === 'win32' ? WINDOW_PIPE_FILE : path.join(os.tmpdir(), SOCK_FILE);
+      }
+    } catch (err) {
+      console.error('Failed to initialize IPC client:', err);
+      this.socketPath = null;
+    }
+  }
+
+  // 连接到 Electron IPC 服务器
+  private connect(): Promise<void> {
+    if (this.connected || !this.socketPath) {
+      return Promise.resolve();
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        this.socket = net.createConnection(this.socketPath!, () => {
+          this.connected = true;
+          this.connectionAttempts = 0;
+          console.log('Connected to Electron IPC server');
+          resolve();
+        });
+
+        this.socket.on('data', (data) => {
+          try {
+            const response = JSON.parse(data.toString());
+            const { id, result, error } = response;
+
+            const pending = this.requestQueue.get(id);
+            if (pending) {
+              this.requestQueue.delete(id);
+              if (error) {
+                pending.reject(new Error(error));
+              } else {
+                pending.resolve(result);
+              }
+            }
+          } catch (err) {
+            console.error('Failed to parse response:', err);
+          }
+        });
+
+        this.socket.on('error', (err) => {
+          console.error('Socket error:', err);
+          this.connected = false;
+          this.handleDisconnect();
+          reject(err);
+        });
+
+        this.socket.on('close', () => {
+          console.log('Socket closed');
+          this.connected = false;
+          this.handleDisconnect();
+        });
+      } catch (err) {
+        console.error('Failed to connect to IPC server:', err);
+        this.handleDisconnect();
+        reject(err);
+      }
+    });
+  }
+
+  // 处理断开连接
+  private handleDisconnect() {
+    // 清除重连定时器
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    // 拒绝所有待处理的请求
+    for (const [, { reject }] of this.requestQueue) {
+      reject(new Error('Connection to Electron IPC server lost'));
+    }
+    this.requestQueue.clear();
+
+    // 尝试重新连接
+    if (this.connectionAttempts < this.maxConnectionAttempts) {
+      this.connectionAttempts++;
+      const delay = Math.min(1000 * Math.pow(2, this.connectionAttempts - 1), 30_000);
+
+      this.reconnectTimeout = setTimeout(() => {
+        this.connect().catch((err) => {
+          console.error(`Reconnection attempt ${this.connectionAttempts} failed:`, err);
+        });
+      }, delay);
+    }
+  }
+
+  // 发送请求到 Electron IPC 服务器
+  public async sendRequest<T>(method: IElectronIPCMethods, params: any = {}): Promise<T> {
+    if (!this.socketPath) {
+      throw new Error('Electron IPC connection not available');
+    }
+
+    // 如果未连接，先连接
+    if (!this.connected) {
+      await this.connect();
+    }
+
+    return new Promise<T>((resolve, reject) => {
+      try {
+        const id = Math.random().toString(36).slice(2, 15);
+        const request = { id, method, params };
+
+        // 将请求添加到队列
+        this.requestQueue.set(id, { reject, resolve });
+
+        // 设置超时
+        const timeout = setTimeout(() => {
+          this.requestQueue.delete(id);
+          reject(new Error(`Request ${method} timed out`));
+        }, 10_000);
+
+        // 发送请求
+        this.socket!.write(JSON.stringify(request), (err) => {
+          if (err) {
+            clearTimeout(timeout);
+            this.requestQueue.delete(id);
+            reject(err);
+          }
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  // 关闭连接
+  public close() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+    }
+
+    this.connected = false;
+  }
+}