@lobehub/chat 1.80.5 → 1.81.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 1.81.0](https://github.com/lobehub/lobe-chat/compare/v1.80.5...v1.81.0)
+
+<sup>Released on **2025-04-17**</sup>
+
+#### ✨ Features
+
+- **misc**: Support search1api as search provider.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Support search1api as search provider, closes [#7449](https://github.com/lobehub/lobe-chat/issues/7449) ([2738cac](https://github.com/lobehub/lobe-chat/commit/2738cac))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.80.5](https://github.com/lobehub/lobe-chat/compare/v1.80.4...v1.80.5)
 
 <sup>Released on **2025-04-17**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Support search1api as search provider."
+      ]
+    },
+    "date": "2025-04-17",
+    "version": "1.81.0"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.80.5",
+  "version": "1.81.0",
   "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",

package/packages/electron-client-ipc/src/events/index.ts

@@ -1,5 +1,6 @@
 import { FilesDispatchEvents } from './file';
 import { MenuDispatchEvents } from './menu';
+import { RemoteServerBroadcastEvents, RemoteServerDispatchEvents } from './remoteServer';
 import { FilesSearchDispatchEvents } from './search';
 import { ShortcutDispatchEvents } from './shortcut';
 import { SystemDispatchEvents } from './system';
@@ -17,7 +18,8 @@ export interface ClientDispatchEvents
     MenuDispatchEvents,
     FilesDispatchEvents,
     AutoUpdateDispatchEvents,
-    ShortcutDispatchEvents {}
+    ShortcutDispatchEvents,
+    RemoteServerDispatchEvents {}
 
 export type ClientDispatchEventKey = keyof ClientDispatchEvents;
 
@@ -29,7 +31,9 @@ export type ClientEventReturnType<T extends ClientDispatchEventKey> = ReturnType
  * main -> render broadcast events
  */
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface MainBroadcastEvents extends AutoUpdateBroadcastEvents {}
+export interface MainBroadcastEvents
+  extends AutoUpdateBroadcastEvents,
+    RemoteServerBroadcastEvents {}
 
 export type MainBroadcastEventKey = keyof MainBroadcastEvents;
 

package/packages/electron-client-ipc/src/events/remoteServer.ts

@@ -0,0 +1,28 @@
+import { RemoteServerConfig } from '../types/remoteServer';
+
+/**
+ * 远程服务器配置相关的事件
+ */
+export interface RemoteServerDispatchEvents {
+  clearRemoteServerConfig: () => boolean;
+  getRemoteServerConfig: () => RemoteServerConfig;
+  refreshAccessToken: () => {
+    error?: string;
+    success: boolean;
+  };
+  requestAuthorization: (serverUrl: string) => {
+    error?: string;
+    success: boolean;
+  };
+  setRemoteServerConfig: (config: RemoteServerConfig) => boolean;
+}
+
+/**
+ * 从主进程广播的远程服务器相关事件
+ */
+export interface RemoteServerBroadcastEvents {
+  authorizationFailed: (params: { error: string }) => void;
+  authorizationRequired: (params: void) => void;
+  authorizationSuccessful: (params: void) => void;
+  tokenRefreshed: (params: void) => void;
+}

package/packages/electron-client-ipc/src/types/index.ts

@@ -1,5 +1,6 @@
 export * from './dispatch';
 export * from './file';
+export * from './remoteServer';
 export * from './route';
 export * from './shortcut';
 export * from './update';

package/packages/electron-client-ipc/src/types/remoteServer.ts

@@ -0,0 +1,8 @@
+/**
+ * 远程服务器配置相关的事件
+ */
+export interface RemoteServerConfig {
+  active: boolean;
+  isSelfHosted: boolean;
+  remoteServerUrl?: string;
+}

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

@@ -3,5 +3,11 @@
   "version": "1.0.0",
   "private": true,
   "main": "src/index.ts",
-  "types": "src/index.ts"
+  "types": "src/index.ts",
+  "dependencies": {
+    "debug": "^4.3.4"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7"
+  }
 }

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

@@ -1,3 +1,4 @@
+import debug from 'debug';
 import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
@@ -6,6 +7,8 @@ import path from 'node:path';
 import { SOCK_FILE, SOCK_INFO_FILE, WINDOW_PIPE_FILE } from './const';
 import { ServerDispatchEventKey } from './events';
 
+const log = debug('electron-server-ipc:client');
+
 export class ElectronIpcClient {
   private socketPath: string | null = null;
   private connected: boolean = false;
@@ -19,6 +22,7 @@ export class ElectronIpcClient {
   private dataBuffer: string = '';
 
   constructor() {
+    log('Initializing client');
     this.initialize();
   }
 
@@ -29,13 +33,16 @@ export class ElectronIpcClient {
       const tempDir = os.tmpdir();
       const socketInfoPath = path.join(tempDir, SOCK_INFO_FILE);
 
+      log('Looking for socket info at: %s', socketInfoPath);
       if (fs.existsSync(socketInfoPath)) {
         const socketInfo = JSON.parse(fs.readFileSync(socketInfoPath, 'utf8'));
         this.socketPath = socketInfo.socketPath;
+        log('Found socket path: %s', this.socketPath);
       } else {
         // 如果找不到套接字信息，使用默认路径
         this.socketPath =
           process.platform === 'win32' ? WINDOW_PIPE_FILE : path.join(os.tmpdir(), SOCK_FILE);
+        log('Socket info not found, using default path: %s', this.socketPath);
       }
     } catch (err) {
       console.error('Failed to initialize IPC client:', err);
@@ -46,21 +53,23 @@ export class ElectronIpcClient {
   // 连接到 Electron IPC 服务器
   private connect(): Promise<void> {
     if (this.connected || !this.socketPath) {
+      log('Connection skipped: Connected=%s, SocketPath=%s', this.connected, !!this.socketPath);
       return Promise.resolve();
     }
 
+    log('Attempting to connect to socket: %s', this.socketPath);
     return new Promise((resolve, reject) => {
       try {
         this.socket = net.createConnection(this.socketPath!, () => {
           this.connected = true;
           this.connectionAttempts = 0;
-          console.log('[ElectronIpcClient] Connected to Electron IPC server');
+          log('Connected to Electron IPC server');
           resolve();
         });
 
         this.socket.on('data', (data) => {
           const dataStr = data.toString();
-          console.log('output:', dataStr);
+          log('Received data: %s', dataStr.length > 100 ? `${dataStr.slice(0, 100)}...` : dataStr);
 
           // 将新数据添加到缓冲区
           this.dataBuffer += dataStr;
@@ -70,6 +79,7 @@ export class ElectronIpcClient {
 
           // 最后一个元素可能是不完整的消息，保留在缓冲区
           this.dataBuffer = messages.pop() || '';
+          log('Buffer remainder: %d bytes', this.dataBuffer.length);
 
           for (const message of messages) {
             if (!message.trim()) continue; // 跳过空消息
@@ -77,41 +87,42 @@ export class ElectronIpcClient {
             try {
               const response = JSON.parse(message);
               const { id, result, error } = response;
+              log('Parsed response for request ID: %s, has error: %s', id, !!error);
 
               const pending = this.requestQueue.get(id);
               if (pending) {
+                log('Found pending request for ID: %s', id);
                 this.requestQueue.delete(id);
                 if (error) {
+                  console.error('Error in response for ID %s: %s', id, error);
                   pending.reject(new Error(error));
                 } else {
+                  log('Resolving request ID: %s', id);
                   pending.resolve(result);
                 }
+              } else {
+                log('No pending request found for ID: %s', id);
               }
             } catch (err) {
-              console.error(
-                '[ElectronIpcClient] Failed to parse response:',
-                err,
-                'message:',
-                message,
-              );
+              console.error('Failed to parse response: %o, message: %s', err, message);
             }
           }
         });
 
         this.socket.on('error', (err) => {
-          console.error('[ElectronIpcClient] Socket error:', err);
+          console.error('Socket error: %o', err);
           this.connected = false;
           this.handleDisconnect();
           reject(err);
         });
 
         this.socket.on('close', () => {
-          console.log('[ElectronIpcClient] Socket closed');
+          log('Socket closed');
           this.connected = false;
           this.handleDisconnect();
         });
       } catch (err) {
-        console.error('[ElectronIpcClient] Failed to connect to IPC server:', err);
+        console.error('Failed to connect to IPC server: %o', err);
         this.handleDisconnect();
         reject(err);
       }
@@ -120,18 +131,23 @@ export class ElectronIpcClient {
 
   // 处理断开连接
   private handleDisconnect() {
+    log('Handling disconnect, connection attempts: %d', this.connectionAttempts);
     // 清除重连定时器
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
+      log('Cleared reconnect timeout');
     }
 
     // 清空数据缓冲区
     this.dataBuffer = '';
 
     // 拒绝所有待处理的请求
-    for (const [, { reject }] of this.requestQueue) {
-      reject(new Error('[ElectronIpcClient] Connection to Electron IPC server lost'));
+    const pendingCount = this.requestQueue.size;
+    log('Rejecting %d pending requests', pendingCount);
+    for (const [id, { reject }] of this.requestQueue) {
+      log('Rejecting request ID: %s', id);
+      reject(new Error('Connection to Electron IPC server lost'));
     }
     this.requestQueue.clear();
 
@@ -139,52 +155,66 @@ export class ElectronIpcClient {
     if (this.connectionAttempts < this.maxConnectionAttempts) {
       this.connectionAttempts++;
       const delay = Math.min(1000 * Math.pow(2, this.connectionAttempts - 1), 30_000);
+      log('Scheduling reconnection attempt %d in %dms', this.connectionAttempts, delay);
 
       this.reconnectTimeout = setTimeout(() => {
+        log('Attempting reconnection #%d', this.connectionAttempts);
         this.connect().catch((err) => {
-          console.error(
-            `[ElectronIpcClient] Reconnection attempt ${this.connectionAttempts} failed:`,
-            err,
-          );
+          console.error('Reconnection attempt %d failed: %o', this.connectionAttempts, err);
         });
       }, delay);
+    } else {
+      log('Reached maximum connection attempts, giving up');
     }
   }
 
   // 发送请求到 Electron IPC 服务器
   public async sendRequest<T>(method: ServerDispatchEventKey, params: any = {}): Promise<T> {
     if (!this.socketPath) {
-      throw new Error('[ElectronIpcClient] Electron IPC connection not available');
+      console.error('Cannot send request: Electron IPC connection not available');
+      throw new Error('Electron IPC connection not available');
     }
 
     // 如果未连接，先连接
     if (!this.connected) {
+      log('Not connected, connecting before sending request');
       await this.connect();
     }
 
+    log('Sending request: %s %o', method, params);
     return new Promise<T>((resolve, reject) => {
       try {
         const id = Math.random().toString(36).slice(2, 15);
         const request = { id, method, params };
+        log('Created request with ID: %s', id);
 
         // 将请求添加到队列
         this.requestQueue.set(id, { reject, resolve });
+        log('Added request to queue, current queue size: %d', this.requestQueue.size);
 
         // 设置超时
         const timeout = setTimeout(() => {
           this.requestQueue.delete(id);
-          reject(new Error(`[ElectronIpcClient] Request timed out, method: ${method}`));
+          const errorMsg = `Request timed out, method: ${method}`;
+          console.error('Request timed out, ID: %s, method: %s', id, method);
+          reject(new Error(errorMsg));
         }, 5000);
 
         // 发送请求
-        this.socket!.write(JSON.stringify(request), (err) => {
+        const requestJson = JSON.stringify(request);
+        log('Writing request to socket, size: %d bytes', requestJson.length);
+        this.socket!.write(requestJson, (err) => {
           if (err) {
             clearTimeout(timeout);
             this.requestQueue.delete(id);
+            console.error('Failed to write request to socket: %o', err);
             reject(err);
+          } else {
+            log('Request successfully written to socket, ID: %s', id);
           }
         });
       } catch (err) {
+        console.error('Error sending request: %o', err);
         reject(err);
       }
     });
@@ -192,16 +222,20 @@ export class ElectronIpcClient {
 
   // 关闭连接
   public close() {
+    log('Closing client connection');
     if (this.reconnectTimeout) {
       clearTimeout(this.reconnectTimeout);
       this.reconnectTimeout = null;
+      log('Cleared reconnect timeout');
     }
 
     if (this.socket) {
+      log('Ending socket connection');
       this.socket.end();
       this.socket = null;
     }
 
     this.connected = false;
+    log('Client connection closed');
   }
 }

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

@@ -1,3 +1,4 @@
+import debug from 'debug';
 import fs from 'node:fs';
 import net from 'node:net';
 import os from 'node:os';
@@ -7,6 +8,8 @@ import { SOCK_FILE, SOCK_INFO_FILE, WINDOW_PIPE_FILE } from './const';
 import { ServerDispatchEventKey } from './events';
 import { ElectronIPCEventHandler } from './types';
 
+const log = debug('electron-server-ipc:server');
+
 export class ElectronIPCServer {
   private server: net.Server;
   private socketPath: string;
@@ -19,10 +22,12 @@ export class ElectronIPCServer {
 
     // 如果是 Unix 套接字，确保文件不存在
     if (!isWindows && fs.existsSync(this.socketPath)) {
+      log('Removing existing socket file at: %s', this.socketPath);
       fs.unlinkSync(this.socketPath);
     }
 
     // 创建服务器
+    log('Creating IPC server');
     this.server = net.createServer(this.handleConnection.bind(this));
 
     this.eventHandler = eventHandler;
@@ -30,18 +35,20 @@ export class ElectronIPCServer {
 
   // 启动服务器
   public start(): Promise<void> {
+    log('Starting IPC server');
     return new Promise((resolve, reject) => {
       this.server.on('error', (err) => {
-        console.error('IPC Server error:', err);
+        console.error('IPC Server error: %o', err);
         reject(err);
       });
 
       this.server.listen(this.socketPath, () => {
-        console.log(`[ElectronIPCServer] Electron IPC server listening on ${this.socketPath}`);
+        log('Electron IPC server listening on %s', this.socketPath);
 
         // 将套接字路径写入临时文件，供 Next.js 服务端读取
         const tempDir = os.tmpdir();
         const socketInfoPath = path.join(tempDir, SOCK_INFO_FILE);
+        log('Writing socket info to: %s', socketInfoPath);
         fs.writeFileSync(socketInfoPath, JSON.stringify({ socketPath: this.socketPath }), 'utf8');
 
         resolve();
@@ -52,62 +59,88 @@ export class ElectronIPCServer {
   // 处理客户端连接
   private handleConnection(socket: net.Socket): void {
     let dataBuffer = '';
+    log('New client connection established');
 
     socket.on('data', (data) => {
-      dataBuffer += data.toString();
+      const chunk = data.toString();
+      log('Received data chunk, size: %d bytes', chunk.length);
+      dataBuffer += chunk;
 
       try {
         // 尝试解析 JSON 消息
         const message = JSON.parse(dataBuffer);
+        log('Successfully parsed JSON message: %o', {
+          id: message.id,
+          method: message.method,
+        });
         dataBuffer = ''; // 重置缓冲区
 
         // 处理请求
         this.handleRequest(socket, message);
       } catch {
         // 如果不是有效的 JSON，可能是消息不完整，继续等待
+        log('Incomplete or invalid JSON, buffering for more data');
       }
     });
 
     socket.on('error', (err) => {
-      console.error('Socket error:', err);
+      console.error('Socket error: %o', err);
+    });
+
+    socket.on('close', () => {
+      log('Client connection closed');
     });
   }
 
   // 处理客户端请求
   private handleRequest = async (socket: net.Socket, request: any) => {
     const { id, method, params } = request;
+    log('Handling request: %s (ID: %s)', method, id);
 
     // 根据请求方法执行相应的操作
     const eventHandler = this.eventHandler[method as ServerDispatchEventKey];
-    if (!eventHandler) return;
+    if (!eventHandler) {
+      console.error('No handler found for method: %s', method);
+      return;
+    }
 
     try {
+      log('Executing handler for method: %s with params: %o', method, params);
       const data = await eventHandler(params, { id, method, socket });
+      log('Handler execution successful for method: %s', method);
 
       this.sendResult(socket, id, data);
     } catch (err) {
-      this.sendError(socket, id, `Failed to handle method(${method}): ${(err as Error).message}`);
+      const errorMsg = `Failed to handle method(${method}): ${(err as Error).message}`;
+      console.error('Error handling request: %s', errorMsg);
+      this.sendError(socket, id, errorMsg);
     }
   };
 
   // 发送结果
   private sendResult(socket: net.Socket, id: string, result: any): void {
-    socket.write(JSON.stringify({ id, result }) + '\n');
+    const response = JSON.stringify({ id, result }) + '\n';
+    log('Sending success response for ID: %s, size: %d bytes', id, response.length);
+    socket.write(response);
   }
 
   // 发送错误
   private sendError(socket: net.Socket, id: string, error: string): void {
-    socket.write(JSON.stringify({ error, id }) + '\n');
+    const response = JSON.stringify({ error, id }) + '\n';
+    log('Sending error response for ID: %s: %s', id, error);
+    socket.write(response);
   }
 
   // 关闭服务器
   public close(): Promise<void> {
+    log('Closing IPC server');
     return new Promise((resolve) => {
       this.server.close(() => {
-        console.log('Electron IPC server closed');
+        log('Electron IPC server closed');
 
         // 删除套接字文件（Unix 平台）
         if (process.platform !== 'win32' && fs.existsSync(this.socketPath)) {
+          log('Removing socket file: %s', this.socketPath);
           fs.unlinkSync(this.socketPath);
         }