@lobehub/lobehub 2.0.0-next.37 → 2.0.0-next.39

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/changelog/v1.json

@@ -1,4 +1,18 @@
 [
+  {
+    "children": {},
+    "date": "2025-11-08",
+    "version": "2.0.0-next.39"
+  },
+  {
+    "children": {
+      "improvements": [
+        "Update i18n."
+      ]
+    },
+    "date": "2025-11-08",
+    "version": "2.0.0-next.38"
+  },
   {
     "children": {
       "fixes": [

package/locales/ar/auth.json

@@ -145,6 +145,50 @@
     "apikey": "إدارة مفاتيح API",
     "profile": "الملف الشخصي",
     "security": "الأمان",
-    "stats": "الإحصائيات"
+    "stats": "الإحصائيات",
+    "usage": "إحصاءات الاستخدام"
+  },
+  "usage": {
+    "activeModels": {
+      "modelTable": "قائمة النماذج",
+      "models": "النماذج النشطة",
+      "providerTable": "قائمة المزودين",
+      "providers": "المزودون النشطون",
+      "table": {
+        "calls": "عدد الاستدعاءات",
+        "model": "النموذج",
+        "provider": "المزود",
+        "spend": "التكلفة"
+      }
+    },
+    "cards": {
+      "month": {
+        "modelCalls": "استدعاءات النموذج",
+        "title": "إنفاق هذا الشهر"
+      },
+      "today": {
+        "title": "إنفاق اليوم",
+        "yesterday": "أمس"
+      }
+    },
+    "table": {
+      "actions": "إجراءات",
+      "createdAt": "وقت الاستخدام",
+      "inputTokens": "رموز الإدخال",
+      "model": "النموذج",
+      "outputTokens": "رموز الإخراج",
+      "spend": "التكلفة",
+      "tps": "TPS",
+      "ttft": "TTFT",
+      "type": "نوع الاستدعاء"
+    },
+    "trends": {
+      "spend": "المبلغ",
+      "tokens": "الرموز"
+    },
+    "welcome": {
+      "model": "النموذج",
+      "provider": "المزود"
+    }
   }
 }

package/locales/ar/modelProvider.json

@@ -199,6 +199,12 @@
     "all": "الكل",
     "list": {
       "disabled": "غير مفعل",
+      "disabledActions": {
+        "sort": "طريقة الترتيب",
+        "sortAlphabetical": "ترتيب أبجديًا",
+        "sortAlphabeticalDesc": "ترتيب أبجدي عكسي",
+        "sortDefault": "الترتيب الافتراضي"
+      },
       "enabled": "مفعل"
     },
     "notFound": "لم يتم العثور على نتائج البحث",
@@ -391,7 +397,13 @@
       "addNew": "إضافة نموذج",
       "disabled": "غير مفعل",
       "disabledActions": {
-        "showMore": "عرض الكل"
+        "showMore": "عرض الكل",
+        "sort": "طريقة الترتيب",
+        "sortAlphabetical": "ترتيب أبجديًا",
+        "sortAlphabeticalDesc": "ترتيب أبجدي عكسي",
+        "sortDefault": "الترتيب الافتراضي",
+        "sortReleasedAt": "ترتيب حسب أقدم تاريخ إصدار",
+        "sortReleasedAtDesc": "ترتيب حسب أحدث تاريخ إصدار"
       },
       "empty": {
         "desc": "يرجى إنشاء نموذج مخصص أو سحب نموذج للبدء في الاستخدام",

package/locales/bg-BG/auth.json

@@ -145,6 +145,50 @@
     "apikey": "Управление на API ключове",
     "profile": "Профил",
     "security": "Сигурност",
-    "stats": "Статистика"
+    "stats": "Статистика",
+    "usage": "Статистика за използване"
+  },
+  "usage": {
+    "activeModels": {
+      "modelTable": "Списък с модели",
+      "models": "Активни модели",
+      "providerTable": "Списък с доставчици",
+      "providers": "Активни доставчици",
+      "table": {
+        "calls": "Брой извиквания",
+        "model": "Модел",
+        "provider": "Доставчик",
+        "spend": "Разходи"
+      }
+    },
+    "cards": {
+      "month": {
+        "modelCalls": "Извиквания на модела",
+        "title": "Разходи за този месец"
+      },
+      "today": {
+        "title": "Разходи за днес",
+        "yesterday": "Вчера"
+      }
+    },
+    "table": {
+      "actions": "Действия",
+      "createdAt": "Време на използване",
+      "inputTokens": "Входни токени",
+      "model": "Модел",
+      "outputTokens": "Изходни токени",
+      "spend": "Разходи",
+      "tps": "TPS",
+      "ttft": "TTFT",
+      "type": "Тип извикване"
+    },
+    "trends": {
+      "spend": "Сума",
+      "tokens": "Токени"
+    },
+    "welcome": {
+      "model": "Модел",
+      "provider": "Доставчик"
+    }
   }
 }

package/locales/bg-BG/modelProvider.json

@@ -199,6 +199,12 @@
     "all": "Всички",
     "list": {
       "disabled": "Неактивиран",
+      "disabledActions": {
+        "sort": "Сортиране",
+        "sortAlphabetical": "Сортиране по азбучен ред",
+        "sortAlphabeticalDesc": "Сортиране по обратен азбучен ред",
+        "sortDefault": "Сортиране по подразбиране"
+      },
       "enabled": "Активиран"
     },
     "notFound": "Не са намерени резултати от търсенето",
@@ -391,7 +397,13 @@
       "addNew": "Добавяне на модел",
       "disabled": "Неактивен",
       "disabledActions": {
-        "showMore": "Покажи всичко"
+        "showMore": "Покажи всичко",
+        "sort": "Сортиране",
+        "sortAlphabetical": "Сортиране по азбучен ред",
+        "sortAlphabeticalDesc": "Сортиране по обратен азбучен ред",
+        "sortDefault": "Сортиране по подразбиране",
+        "sortReleasedAt": "Сортиране по най-ранна дата на публикуване",
+        "sortReleasedAtDesc": "Сортиране по най-нова дата на публикуване"
       },
       "empty": {
         "desc": "Моля, създайте персонализиран модел или изтеглете модел, за да започнете да го използвате",