@lobehub/lobehub 2.0.0-next.9 → 2.0.0-next.90

package/apps/desktop/src/main/modules/networkProxy/__tests__/validator.test.ts

@@ -0,0 +1,492 @@
+import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
+import { describe, expect, it } from 'vitest';
+
+import { ProxyConfigValidator } from '../validator';
+
+describe('ProxyConfigValidator', () => {
+  const validConfig: NetworkProxySettings = {
+    enableProxy: true,
+    proxyType: 'http',
+    proxyServer: 'proxy.example.com',
+    proxyPort: '8080',
+    proxyRequireAuth: false,
+    proxyBypass: 'localhost,127.0.0.1,::1',
+  };
+
+  describe('validate', () => {
+    describe('disabled proxy', () => {
+      it('should validate successfully when proxy is disabled', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          enableProxy: false,
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should skip validation for disabled proxy even with invalid fields', () => {
+        const config: NetworkProxySettings = {
+          enableProxy: false,
+          proxyType: 'invalid' as any,
+          proxyServer: '',
+          proxyPort: 'invalid',
+          proxyRequireAuth: false,
+          proxyBypass: 'localhost',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+    });
+
+    describe('proxy type validation', () => {
+      it('should accept http proxy type', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyType: 'http',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept https proxy type', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyType: 'https',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept socks5 proxy type', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyType: 'socks5',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should reject unsupported proxy type', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyType: 'socks4' as any,
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('Unsupported proxy type');
+        expect(result.errors[0]).toContain('socks4');
+      });
+
+      it('should reject invalid proxy type', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyType: 'ftp' as any,
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors[0]).toContain('Supported types: http, https, socks5');
+      });
+    });
+
+    describe('proxy server validation', () => {
+      it('should accept valid domain name', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'proxy.example.com',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept valid IPv4 address', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: '192.168.1.1',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept localhost', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'localhost',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept subdomain', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'proxy.subdomain.example.com',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should reject empty proxy server', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: '',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy server is required when proxy is enabled');
+      });
+
+      it('should reject whitespace-only proxy server', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: '   ',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy server is required when proxy is enabled');
+      });
+
+      it('should reject invalid domain format', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'invalid..domain',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Invalid proxy server format');
+      });
+
+      it('should reject domain starting with hyphen', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: '-proxy.com',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Invalid proxy server format');
+      });
+
+      it('should reject domain with invalid characters', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'proxy@example.com',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Invalid proxy server format');
+      });
+    });
+
+    describe('proxy port validation', () => {
+      it('should accept valid port 1', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '1',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept valid port 65535', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '65535',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should accept common proxy port 8080', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '8080',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should reject empty proxy port', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port is required when proxy is enabled');
+      });
+
+      it('should reject whitespace-only proxy port', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '   ',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port is required when proxy is enabled');
+      });
+
+      it('should reject port 0', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '0',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port must be a valid number between 1 and 65535');
+      });
+
+      it('should reject port above 65535', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '65536',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port must be a valid number between 1 and 65535');
+      });
+
+      it('should reject negative port', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: '-1',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port must be a valid number between 1 and 65535');
+      });
+
+      it('should reject non-numeric port', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyPort: 'abc',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain('Proxy port must be a valid number between 1 and 65535');
+      });
+    });
+
+    describe('authentication validation', () => {
+      it('should validate successfully with auth disabled', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: false,
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should validate successfully with auth enabled and credentials provided', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: 'testuser',
+          proxyPassword: 'testpass',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+
+      it('should reject when auth is enabled but username is missing', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: '',
+          proxyPassword: 'testpass',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain(
+          'Proxy username is required when authentication is enabled',
+        );
+      });
+
+      it('should reject when auth is enabled but username is whitespace', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: '   ',
+          proxyPassword: 'testpass',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain(
+          'Proxy username is required when authentication is enabled',
+        );
+      });
+
+      it('should reject when auth is enabled but password is missing', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: 'testuser',
+          proxyPassword: '',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain(
+          'Proxy password is required when authentication is enabled',
+        );
+      });
+
+      it('should reject when auth is enabled but password is whitespace', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: 'testuser',
+          proxyPassword: '   ',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toContain(
+          'Proxy password is required when authentication is enabled',
+        );
+      });
+
+      it('should reject when auth is enabled but both username and password are missing', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: true,
+          proxyUsername: '',
+          proxyPassword: '',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toHaveLength(2);
+        expect(result.errors).toContain(
+          'Proxy username is required when authentication is enabled',
+        );
+        expect(result.errors).toContain(
+          'Proxy password is required when authentication is enabled',
+        );
+      });
+
+      it('should allow missing credentials when auth is disabled', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyRequireAuth: false,
+          proxyUsername: undefined,
+          proxyPassword: undefined,
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+      });
+    });
+
+    describe('multiple validation errors', () => {
+      it('should collect all validation errors', () => {
+        const config: NetworkProxySettings = {
+          enableProxy: true,
+          proxyType: 'invalid' as any,
+          proxyServer: '',
+          proxyPort: 'abc',
+          proxyRequireAuth: true,
+          proxyUsername: '',
+          proxyPassword: '',
+          proxyBypass: 'localhost',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(1);
+      });
+
+      it('should collect errors for invalid server and port', () => {
+        const config: NetworkProxySettings = {
+          ...validConfig,
+          proxyServer: 'invalid..domain',
+          proxyPort: '99999',
+        };
+
+        const result = ProxyConfigValidator.validate(config);
+
+        expect(result.isValid).toBe(false);
+        expect(result.errors).toHaveLength(2);
+        expect(result.errors).toContain('Invalid proxy server format');
+        expect(result.errors).toContain('Proxy port must be a valid number between 1 and 65535');
+      });
+    });
+  });
+});

package/apps/desktop/src/main/modules/networkProxy/dispatcher.ts

@@ -10,14 +10,14 @@ import { ProxyUrlBuilder } from './urlBuilder';
 const logger = createLogger('modules:networkProxy:dispatcher');
 
 /**
- * 代理管理器
+ * Proxy dispatcher manager
  */
 export class ProxyDispatcherManager {
   private static isChanging = false;
   private static changeQueue: Array<() => Promise<void>> = [];
 
   /**
-   * 应用代理设置（带并发控制）
+   * Apply proxy settings (with concurrency control)
    */
   static async applyProxySettings(config: NetworkProxySettings): Promise<void> {
     return new Promise((resolve, reject) => {
@@ -31,17 +31,17 @@ export class ProxyDispatcherManager {
       };
 
       if (this.isChanging) {
-        // 如果正在切换，加入队列
+        // If currently switching, add to queue
         this.changeQueue.push(operation);
       } else {
-        // 立即执行
+        // Execute immediately
         operation();
       }
     });
   }
 
   /**
-   * 执行代理设置应用
+   * Execute proxy settings application
    */
   private static async doApplyProxySettings(config: NetworkProxySettings): Promise<void> {
     this.isChanging = true;
@@ -49,22 +49,22 @@ export class ProxyDispatcherManager {
     try {
       const currentDispatcher = getGlobalDispatcher();
 
-      // 禁用代理，恢复默认连接
+      // Disable proxy, restore default connection
       if (!config.enableProxy) {
         await this.safeDestroyDispatcher(currentDispatcher);
-        // 创建一个新的默认 Agent 来替代代理
+        // Create a new default Agent to replace the proxy
         setGlobalDispatcher(new Agent());
         logger.debug('Proxy disabled, reset to direct connection mode');
         return;
       }
 
-      // 构建代理 URL
+      // Build proxy URL
       const proxyUrl = ProxyUrlBuilder.build(config);
 
-      // 创建代理 agent
+      // Create proxy agent
       const agent = this.createProxyAgent(config.proxyType, proxyUrl);
 
-      // 切换代理前销毁旧 dispatcher
+      // Destroy old dispatcher before switching proxy
       await this.safeDestroyDispatcher(currentDispatcher);
       setGlobalDispatcher(agent);
 
@@ -77,7 +77,7 @@ export class ProxyDispatcherManager {
     } finally {
       this.isChanging = false;
 
-      // 处理队列中的下一个操作
+      // Process next operation in queue
       if (this.changeQueue.length > 0) {
         const nextOperation = this.changeQueue.shift();
         if (nextOperation) {
@@ -88,12 +88,12 @@ export class ProxyDispatcherManager {
   }
 
   /**
-   * 创建代理 agent
+   * Create proxy agent
    */
   static createProxyAgent(proxyType: string, proxyUrl: string) {
     try {
       if (proxyType === 'socks5') {
-        // 解析 SOCKS5 代理 URL
+        // Parse SOCKS5 proxy URL
         const url = new URL(proxyUrl);
         const socksProxies: SocksProxies = [
           {
@@ -109,10 +109,10 @@ export class ProxyDispatcherManager {
           },
         ];
 
-        // 使用 fetch-socks 处理 SOCKS5 代理
+        // Use fetch-socks to handle SOCKS5 proxy
         return socksDispatcher(socksProxies);
       } else {
-        // undici 的 ProxyAgent 支持 http, https
+        // undici's ProxyAgent supports http, https
         return new ProxyAgent({ uri: proxyUrl });
       }
     } catch (error) {
@@ -124,7 +124,7 @@ export class ProxyDispatcherManager {
   }
 
   /**
-   * 安全销毁 dispatcher
+   * Safely destroy dispatcher
    */
   private static async safeDestroyDispatcher(dispatcher: any): Promise<void> {
     try {

package/apps/desktop/src/main/modules/networkProxy/tester.ts

@@ -11,7 +11,7 @@ import { ProxyConfigValidator } from './validator';
 const logger = createLogger('modules:networkProxy:tester');
 
 /**
- * 代理连接测试结果
+ * Proxy connection test result
  */
 export interface ProxyTestResult {
   message?: string;
@@ -20,14 +20,14 @@ export interface ProxyTestResult {
 }
 
 /**
- * 代理连接测试器
+ * Proxy connection tester
  */
 export class ProxyConnectionTester {
-  private static readonly DEFAULT_TIMEOUT = 10_000; // 10秒超时
+  private static readonly DEFAULT_TIMEOUT = 10_000; // 10 seconds timeout
   private static readonly DEFAULT_TEST_URL = 'https://www.google.com';
 
   /**
-   * 测试代理连接
+   * Test proxy connection
    */
   static async testConnection(
     url: string = this.DEFAULT_TEST_URL,
@@ -77,13 +77,13 @@ export class ProxyConnectionTester {
   }
 
   /**
-   * 测试指定代理配置的连接
+   * Test connection with specified proxy configuration
    */
   static async testProxyConfig(
     config: NetworkProxySettings,
     testUrl: string = this.DEFAULT_TEST_URL,
   ): Promise<ProxyTestResult> {
-    // 验证配置
+    // Validate configuration
     const validation = ProxyConfigValidator.validate(config);
     if (!validation.isValid) {
       return {
@@ -92,12 +92,12 @@ export class ProxyConnectionTester {
       };
     }
 
-    // 如果未启用代理，直接测试
+    // If proxy is not enabled, test directly
     if (!config.enableProxy) {
       return this.testConnection(testUrl);
     }
 
-    // 创建临时代理 agent 进行测试
+    // Create temporary proxy agent for testing
     try {
       const proxyUrl = ProxyUrlBuilder.build(config);
       logger.debug(`Testing proxy with URL: ${proxyUrl}`);
@@ -108,7 +108,7 @@ export class ProxyConnectionTester {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), this.DEFAULT_TIMEOUT);
 
-      // 临时设置代理进行测试
+      // Temporarily set proxy for testing
       const originalDispatcher = getGlobalDispatcher();
       setGlobalDispatcher(agent);
 
@@ -138,9 +138,9 @@ export class ProxyConnectionTester {
         clearTimeout(timeoutId);
         throw fetchError;
       } finally {
-        // 恢复原来的 dispatcher
+        // Restore original dispatcher
         setGlobalDispatcher(originalDispatcher);
-        // 清理临时创建的代理 agent
+        // Clean up temporary proxy agent
         if (agent && typeof agent.destroy === 'function') {
           try {
             await agent.destroy();

package/apps/desktop/src/main/modules/networkProxy/urlBuilder.ts

@@ -1,11 +1,11 @@
 import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
 
 /**
- * 代理 URL 构建器
+ * Proxy URL builder
  */
 export const ProxyUrlBuilder = {
   /**
-   * 构建代理 URL
+   * Build proxy URL
    */
   build(config: NetworkProxySettings): string {
     const { proxyType, proxyServer, proxyPort, proxyRequireAuth, proxyUsername, proxyPassword } =
@@ -13,7 +13,7 @@ export const ProxyUrlBuilder = {
 
     let proxyUrl = `${proxyType}://${proxyServer}:${proxyPort}`;
 
-    // 添加认证信息
+    // Add authentication information
     if (proxyRequireAuth && proxyUsername && proxyPassword) {
       const encodedUsername = encodeURIComponent(proxyUsername);
       const encodedPassword = encodeURIComponent(proxyPassword);