🔨 chore: add electron server ipc (lobehub#7246)

Author: arvinxx

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 桌面应用设计，不作为独立包发布。

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"
+}

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';

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

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

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();
+    });
+  });
+});