@lobehub/chat 1.97.17 → 1.98.0

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

@@ -0,0 +1,116 @@
+import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
+import { Agent, ProxyAgent, getGlobalDispatcher, setGlobalDispatcher } from 'undici';
+
+import { createLogger } from '@/utils/logger';
+
+import { ProxyUrlBuilder } from './urlBuilder';
+
+// Create logger
+const logger = createLogger('modules:networkProxy:dispatcher');
+
+/**
+ * 代理管理器
+ */
+export class ProxyDispatcherManager {
+  private static isChanging = false;
+  private static changeQueue: Array<() => Promise<void>> = [];
+
+  /**
+   * 应用代理设置（带并发控制）
+   */
+  static async applyProxySettings(config: NetworkProxySettings): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const operation = async () => {
+        try {
+          await this.doApplyProxySettings(config);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      };
+
+      if (this.isChanging) {
+        // 如果正在切换，加入队列
+        this.changeQueue.push(operation);
+      } else {
+        // 立即执行
+        operation();
+      }
+    });
+  }
+
+  /**
+   * 执行代理设置应用
+   */
+  private static async doApplyProxySettings(config: NetworkProxySettings): Promise<void> {
+    this.isChanging = true;
+
+    try {
+      const currentDispatcher = getGlobalDispatcher();
+
+      // 禁用代理，恢复默认连接
+      if (!config.enableProxy) {
+        await this.safeDestroyDispatcher(currentDispatcher);
+        // 创建一个新的默认 Agent 来替代代理
+        setGlobalDispatcher(new Agent());
+        logger.debug('Proxy disabled, reset to direct connection mode');
+        return;
+      }
+
+      // 构建代理 URL
+      const proxyUrl = ProxyUrlBuilder.build(config);
+
+      // 创建代理 agent
+      const agent = this.createProxyAgent(config.proxyType, proxyUrl);
+
+      // 切换代理前销毁旧 dispatcher
+      await this.safeDestroyDispatcher(currentDispatcher);
+      setGlobalDispatcher(agent);
+
+      logger.info(
+        `Proxy settings applied: ${config.proxyType}://${config.proxyServer}:${config.proxyPort}`,
+      );
+      logger.debug(
+        'Global request proxy set, all Node.js network requests will go through this proxy',
+      );
+    } finally {
+      this.isChanging = false;
+
+      // 处理队列中的下一个操作
+      if (this.changeQueue.length > 0) {
+        const nextOperation = this.changeQueue.shift();
+        if (nextOperation) {
+          setTimeout(() => nextOperation(), 0);
+        }
+      }
+    }
+  }
+
+  /**
+   * 创建代理 agent
+   */
+  static createProxyAgent(proxyType: string, proxyUrl: string) {
+    try {
+      // undici 的 ProxyAgent 支持 http, https 和 socks5
+      return new ProxyAgent({ uri: proxyUrl });
+    } catch (error) {
+      logger.error(`Failed to create proxy agent for ${proxyType}:`, error);
+      throw new Error(
+        `Failed to create proxy agent: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      );
+    }
+  }
+
+  /**
+   * 安全销毁 dispatcher
+   */
+  private static async safeDestroyDispatcher(dispatcher: any): Promise<void> {
+    try {
+      if (dispatcher && typeof dispatcher.destroy === 'function') {
+        await dispatcher.destroy();
+      }
+    } catch (error) {
+      logger.warn('Failed to destroy dispatcher:', error);
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+export { ProxyDispatcherManager } from './dispatcher';
+export type { ProxyTestResult } from './tester';
+export { ProxyConnectionTester } from './tester';
+export { ProxyUrlBuilder } from './urlBuilder';
+export type { ProxyValidationResult } from './validator';
+export { ProxyConfigValidator } from './validator';

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

@@ -0,0 +1,163 @@
+import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
+import { fetch, getGlobalDispatcher, setGlobalDispatcher } from 'undici';
+
+import { createLogger } from '@/utils/logger';
+
+import { ProxyDispatcherManager } from './dispatcher';
+import { ProxyUrlBuilder } from './urlBuilder';
+import { ProxyConfigValidator } from './validator';
+
+// Create logger
+const logger = createLogger('modules:networkProxy:tester');
+
+/**
+ * 代理连接测试结果
+ */
+export interface ProxyTestResult {
+  message?: string;
+  responseTime?: number;
+  success: boolean;
+}
+
+/**
+ * 代理连接测试器
+ */
+export class ProxyConnectionTester {
+  private static readonly DEFAULT_TIMEOUT = 10_000; // 10秒超时
+  private static readonly DEFAULT_TEST_URL = 'https://www.google.com';
+
+  /**
+   * 测试代理连接
+   */
+  static async testConnection(
+    url: string = this.DEFAULT_TEST_URL,
+    timeout: number = this.DEFAULT_TIMEOUT,
+  ): Promise<ProxyTestResult> {
+    const startTime = Date.now();
+
+    try {
+      logger.info(`Testing proxy connection with URL: ${url}`);
+
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'LobeChat-Desktop/1.0.0',
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      const responseTime = Date.now() - startTime;
+
+      logger.info(`Proxy connection test successful, response time: ${responseTime}ms`);
+
+      return {
+        responseTime,
+        success: true,
+      };
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      logger.error(`Proxy connection test failed after ${responseTime}ms:`, errorMessage);
+
+      return {
+        message: errorMessage,
+        responseTime,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * 测试指定代理配置的连接
+   */
+  static async testProxyConfig(
+    config: NetworkProxySettings,
+    testUrl: string = this.DEFAULT_TEST_URL,
+  ): Promise<ProxyTestResult> {
+    // 验证配置
+    const validation = ProxyConfigValidator.validate(config);
+    if (!validation.isValid) {
+      return {
+        message: `Invalid proxy configuration: ${validation.errors.join(', ')}`,
+        success: false,
+      };
+    }
+
+    // 如果未启用代理，直接测试
+    if (!config.enableProxy) {
+      return this.testConnection(testUrl);
+    }
+
+    // 创建临时代理 agent 进行测试
+    try {
+      const proxyUrl = ProxyUrlBuilder.build(config);
+      logger.debug(`Testing proxy with URL: ${proxyUrl}`);
+
+      const agent = ProxyDispatcherManager.createProxyAgent(config.proxyType, proxyUrl);
+
+      const startTime = Date.now();
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.DEFAULT_TIMEOUT);
+
+      // 临时设置代理进行测试
+      const originalDispatcher = getGlobalDispatcher();
+      setGlobalDispatcher(agent);
+
+      try {
+        const response = await fetch(testUrl, {
+          dispatcher: agent,
+          headers: {
+            'User-Agent': 'LobeChat-Desktop/1.0.0',
+          },
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const responseTime = Date.now() - startTime;
+        logger.info(`Proxy test successful, response time: ${responseTime}ms`);
+
+        return {
+          responseTime,
+          success: true,
+        };
+      } catch (fetchError) {
+        clearTimeout(timeoutId);
+        throw fetchError;
+      } finally {
+        // 恢复原来的 dispatcher
+        setGlobalDispatcher(originalDispatcher);
+        // 清理临时创建的代理 agent
+        if (agent && typeof agent.destroy === 'function') {
+          try {
+            await agent.destroy();
+          } catch (error) {
+            logger.warn('Failed to destroy test agent:', error);
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+      logger.error(`Proxy test failed: ${errorMessage}`, error);
+
+      return {
+        message: `Proxy test failed: ${errorMessage}`,
+        success: false,
+      };
+    }
+  }
+}

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

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

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

@@ -0,0 +1,80 @@
+import { NetworkProxySettings } from '@lobechat/electron-client-ipc';
+
+/**
+ * 代理配置验证结果
+ */
+export interface ProxyValidationResult {
+  errors: string[];
+  isValid: boolean;
+}
+
+/**
+ * 代理配置验证器
+ */
+export class ProxyConfigValidator {
+  private static readonly SUPPORTED_TYPES = ['http', 'https', 'socks5'] as const;
+  private static readonly DEFAULT_BYPASS = 'localhost,127.0.0.1,::1';
+
+  /**
+   * 验证代理配置
+   */
+  static validate(config: NetworkProxySettings): ProxyValidationResult {
+    const errors: string[] = [];
+
+    // 如果未启用代理，跳过验证
+    if (!config.enableProxy) {
+      return { errors: [], isValid: true };
+    }
+
+    // 验证代理类型
+    if (!this.SUPPORTED_TYPES.includes(config.proxyType as any)) {
+      errors.push(
+        `Unsupported proxy type: ${config.proxyType}. Supported types: ${this.SUPPORTED_TYPES.join(', ')}`,
+      );
+    }
+
+    // 验证代理服务器
+    if (!config.proxyServer?.trim()) {
+      errors.push('Proxy server is required when proxy is enabled');
+    } else if (!this.isValidHost(config.proxyServer)) {
+      errors.push('Invalid proxy server format');
+    }
+
+    // 验证代理端口
+    if (!config.proxyPort?.trim()) {
+      errors.push('Proxy port is required when proxy is enabled');
+    } else {
+      const port = parseInt(config.proxyPort, 10);
+      if (isNaN(port) || port < 1 || port > 65_535) {
+        errors.push('Proxy port must be a valid number between 1 and 65535');
+      }
+    }
+
+    // 验证认证信息
+    if (config.proxyRequireAuth) {
+      if (!config.proxyUsername?.trim()) {
+        errors.push('Proxy username is required when authentication is enabled');
+      }
+      if (!config.proxyPassword?.trim()) {
+        errors.push('Proxy password is required when authentication is enabled');
+      }
+    }
+
+    return {
+      errors,
+      isValid: errors.length === 0,
+    };
+  }
+
+  /**
+   * 验证主机名格式
+   */
+  private static isValidHost(host: string): boolean {
+    // 简单的主机名验证（IP 地址或域名）
+    const ipRegex = /^(\d{1,3}\.){3}\d{1,3}$/;
+    const domainRegex =
+      /^[\dA-Za-z]([\dA-Za-z-]*[\dA-Za-z])?(\.[\dA-Za-z]([\dA-Za-z-]*[\dA-Za-z])?)*$/;
+
+    return ipRegex.test(host) || domainRegex.test(host);
+  }
+}

package/apps/desktop/src/main/types/store.ts

@@ -1,4 +1,4 @@
-import { DataSyncConfig } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, NetworkProxySettings } from '@lobechat/electron-client-ipc';
 
 export interface ElectronMainStore {
   dataSyncConfig: DataSyncConfig;
@@ -7,6 +7,7 @@ export interface ElectronMainStore {
     refreshToken?: string;
   };
   locale: string;
+  networkProxy: NetworkProxySettings;
   shortcuts: Record<string, string>;
   storagePath: string;
 }

package/apps/desktop/src/main/utils/logger.ts

@@ -19,8 +19,9 @@ export const createLogger = (namespace: string) => {
     error: (message, ...args) => {
       if (process.env.NODE_ENV === 'production') {
         electronLog.error(message, ...args);
+      } else {
+        console.error(message, ...args);
       }
-      debugLogger(`ERROR: ${message}`, ...args);
     },
     info: (message, ...args) => {
       if (process.env.NODE_ENV === 'production') {

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Add network proxy for desktop."
+      ]
+    },
+    "date": "2025-07-13",
+    "version": "1.98.0"
+  },
   {
     "children": {
       "improvements": [

package/locales/ar/electron.json

@@ -1,4 +1,43 @@
 {
+  "proxy": {
+    "auth": "يتطلب المصادقة",
+    "authDesc": "إذا كان خادم الوكيل يتطلب اسم مستخدم وكلمة مرور",
+    "authSettings": "إعدادات المصادقة",
+    "basicSettings": "إعدادات الوكيل",
+    "basicSettingsDesc": "تكوين معلمات اتصال خادم الوكيل",
+    "bypass": "العناوين التي لا تستخدم الوكيل",
+    "connectionTest": "اختبار الاتصال",
+    "enable": "تفعيل الوكيل",
+    "enableDesc": "عند التفعيل، سيتم الوصول إلى الشبكة عبر خادم الوكيل",
+    "password": "كلمة المرور",
+    "password_placeholder": "الرجاء إدخال كلمة المرور",
+    "port": "المنفذ",
+    "resetButton": "إعادة تعيين",
+    "saveButton": "حفظ",
+    "saveFailed": "فشل الحفظ: {{error}}",
+    "saveSuccess": "تم حفظ إعدادات الوكيل بنجاح",
+    "server": "عنوان الخادم",
+    "testButton": "اختبار الاتصال",
+    "testDescription": "اختبر الاتصال باستخدام إعدادات الوكيل الحالية للتحقق من صحة التكوين",
+    "testFailed": "فشل الاتصال",
+    "testSuccessWithTime": "تم اختبار الاتصال بنجاح، استغرق {{time}} مللي ثانية",
+    "testUrl": "عنوان الاختبار",
+    "testUrlPlaceholder": "الرجاء إدخال عنوان URL للاختبار",
+    "testing": "جارٍ اختبار الاتصال...",
+    "type": "نوع الوكيل",
+    "unsavedChanges": "لديك تغييرات غير محفوظة",
+    "username": "اسم المستخدم",
+    "username_placeholder": "الرجاء إدخال اسم المستخدم",
+    "validation": {
+      "passwordRequired": "كلمة المرور مطلوبة عند تفعيل المصادقة",
+      "portInvalid": "يجب أن يكون المنفذ رقمًا بين 1 و 65535",
+      "portRequired": "المنفذ مطلوب عند تفعيل الوكيل",
+      "serverInvalid": "يرجى إدخال عنوان خادم صالح (IP أو اسم نطاق)",
+      "serverRequired": "عنوان الخادم مطلوب عند تفعيل الوكيل",
+      "typeRequired": "نوع الوكيل مطلوب عند تفعيل الوكيل",
+      "usernameRequired": "اسم المستخدم مطلوب عند تفعيل المصادقة"
+    }
+  },
   "remoteServer": {
     "authError": "فشل التفويض: {{error}}",
     "authPending": "يرجى إكمال التفويض في المتصفح",

package/locales/ar/setting.json

@@ -520,6 +520,7 @@
     "hotkey": "اختصارات لوحة المفاتيح",
     "llm": "نموذج اللغة",
     "provider": "مزود خدمة الذكاء الاصطناعي",
+    "proxy": "وكيل الشبكة",
     "storage": "تخزين البيانات",
     "sync": "مزامنة السحابة",
     "system-agent": "مساعد النظام",

package/locales/bg-BG/electron.json

@@ -1,4 +1,43 @@
 {
+  "proxy": {
+    "auth": "Необходимо удостоверяване",
+    "authDesc": "Ако прокси сървърът изисква потребителско име и парола",
+    "authSettings": "Настройки за удостоверяване",
+    "basicSettings": "Настройки на прокси",
+    "basicSettingsDesc": "Конфигуриране на параметрите за връзка с прокси сървъра",
+    "bypass": "Адреси без прокси",
+    "connectionTest": "Тест на връзката",
+    "enable": "Активиране на прокси",
+    "enableDesc": "При активиране достъпът до мрежата ще се осъществява чрез прокси сървъра",
+    "password": "Парола",
+    "password_placeholder": "Моля, въведете парола",
+    "port": "Порт",
+    "resetButton": "Нулиране",
+    "saveButton": "Запазване",
+    "saveFailed": "Грешка при запазване: {{error}}",
+    "saveSuccess": "Настройките на прокси сървъра бяха успешно запазени",
+    "server": "Адрес на сървъра",
+    "testButton": "Тествай връзката",
+    "testDescription": "Тествайте връзката с текущата прокси конфигурация, за да проверите дали работи правилно",
+    "testFailed": "Връзката неуспешна",
+    "testSuccessWithTime": "Връзката е успешна, време за изпълнение {{time}} ms",
+    "testUrl": "Тестов адрес",
+    "testUrlPlaceholder": "Моля, въведете URL за тест",
+    "testing": "Тест на връзката...",
+    "type": "Тип прокси",
+    "unsavedChanges": "Имате незапазени промени",
+    "username": "Потребителско име",
+    "username_placeholder": "Моля, въведете потребителско име",
+    "validation": {
+      "passwordRequired": "Паролата е задължителна при активиране на удостоверяване",
+      "portInvalid": "Портът трябва да е число между 1 и 65535",
+      "portRequired": "Портът е задължителен при активиране на прокси",
+      "serverInvalid": "Моля, въведете валиден адрес на сървъра (IP или домейн)",
+      "serverRequired": "Адресът на сървъра е задължителен при активиране на прокси",
+      "typeRequired": "Типът прокси е задължителен при активиране на прокси",
+      "usernameRequired": "Потребителското име е задължително при активиране на удостоверяване"
+    }
+  },
   "remoteServer": {
     "authError": "Упълномощаването не бе успешно: {{error}}",
     "authPending": "Моля, завършете упълномощаването в браузъра",

package/locales/bg-BG/setting.json

@@ -520,6 +520,7 @@
     "hotkey": "Бързи клавиши",
     "llm": "Езиков модел",
     "provider": "AI доставчик",
+    "proxy": "Мрежов прокси",
     "storage": "Данни за хранилище",
     "sync": "Синхронизиране в облака",
     "system-agent": "Системен асистент",

package/locales/de-DE/electron.json

@@ -1,4 +1,43 @@
 {
+  "proxy": {
+    "auth": "Authentifizierung erforderlich",
+    "authDesc": "Wenn der Proxy-Server Benutzername und Passwort benötigt",
+    "authSettings": "Authentifizierungseinstellungen",
+    "basicSettings": "Proxy-Einstellungen",
+    "basicSettingsDesc": "Konfigurieren Sie die Verbindungsparameter des Proxy-Servers",
+    "bypass": "Adressen ohne Proxy",
+    "connectionTest": "Verbindungstest",
+    "enable": "Proxy aktivieren",
+    "enableDesc": "Wenn aktiviert, wird der Netzwerkzugang über den Proxy-Server geleitet",
+    "password": "Passwort",
+    "password_placeholder": "Bitte Passwort eingeben",
+    "port": "Port",
+    "resetButton": "Zurücksetzen",
+    "saveButton": "Speichern",
+    "saveFailed": "Speichern fehlgeschlagen: {{error}}",
+    "saveSuccess": "Proxy-Einstellungen erfolgreich gespeichert",
+    "server": "Serveradresse",
+    "testButton": "Verbindung testen",
+    "testDescription": "Testen Sie die Verbindung mit der aktuellen Proxy-Konfiguration, um die Funktionalität zu überprüfen",
+    "testFailed": "Verbindung fehlgeschlagen",
+    "testSuccessWithTime": "Verbindung erfolgreich getestet, Dauer {{time}} ms",
+    "testUrl": "Test-URL",
+    "testUrlPlaceholder": "Bitte die zu testende URL eingeben",
+    "testing": "Verbindung wird getestet...",
+    "type": "Proxy-Typ",
+    "unsavedChanges": "Sie haben ungespeicherte Änderungen",
+    "username": "Benutzername",
+    "username_placeholder": "Bitte Benutzernamen eingeben",
+    "validation": {
+      "passwordRequired": "Passwort ist erforderlich, wenn die Authentifizierung aktiviert ist",
+      "portInvalid": "Der Port muss eine Zahl zwischen 1 und 65535 sein",
+      "portRequired": "Port ist erforderlich, wenn der Proxy aktiviert ist",
+      "serverInvalid": "Bitte geben Sie eine gültige Serveradresse (IP oder Domain) ein",
+      "serverRequired": "Serveradresse ist erforderlich, wenn der Proxy aktiviert ist",
+      "typeRequired": "Proxy-Typ ist erforderlich, wenn der Proxy aktiviert ist",
+      "usernameRequired": "Benutzername ist erforderlich, wenn die Authentifizierung aktiviert ist"
+    }
+  },
   "remoteServer": {
     "authError": "Autorisierung fehlgeschlagen: {{error}}",
     "authPending": "Bitte schließen Sie die Autorisierung im Browser ab",

package/locales/de-DE/setting.json

@@ -520,6 +520,7 @@
     "hotkey": "Tastenkombinationen",
     "llm": "Sprachmodell",
     "provider": "KI-Dienstanbieter",
+    "proxy": "Netzwerkproxy",
     "storage": "Datenspeicher",
     "sync": "Cloud-Synchronisierung",
     "system-agent": "Systemassistent",

package/locales/en-US/electron.json

@@ -1,4 +1,43 @@
 {
+  "proxy": {
+    "auth": "Authentication Required",
+    "authDesc": "If the proxy server requires a username and password",
+    "authSettings": "Authentication Settings",
+    "basicSettings": "Proxy Settings",
+    "basicSettingsDesc": "Configure the connection parameters for the proxy server",
+    "bypass": "Addresses not using the proxy",
+    "connectionTest": "Connection Test",
+    "enable": "Enable Proxy",
+    "enableDesc": "When enabled, network access will be routed through the proxy server",
+    "password": "Password",
+    "password_placeholder": "Please enter your password",
+    "port": "Port",
+    "resetButton": "Reset",
+    "saveButton": "Save",
+    "saveFailed": "Save failed: {{error}}",
+    "saveSuccess": "Proxy settings saved successfully",
+    "server": "Server Address",
+    "testButton": "Test Connection",
+    "testDescription": "Test the connection using the current proxy configuration to verify if it works properly",
+    "testFailed": "Connection failed",
+    "testSuccessWithTime": "Connection test succeeded, took {{time}} ms",
+    "testUrl": "Test URL",
+    "testUrlPlaceholder": "Please enter the URL to test",
+    "testing": "Testing Connection...",
+    "type": "Proxy Type",
+    "unsavedChanges": "You have unsaved changes",
+    "username": "Username",
+    "username_placeholder": "Please enter your username",
+    "validation": {
+      "passwordRequired": "Password is required when authentication is enabled",
+      "portInvalid": "Port must be a number between 1 and 65535",
+      "portRequired": "Port is required when proxy is enabled",
+      "serverInvalid": "Please enter a valid server address (IP or domain name)",
+      "serverRequired": "Server address is required when proxy is enabled",
+      "typeRequired": "Proxy type is required when proxy is enabled",
+      "usernameRequired": "Username is required when authentication is enabled"
+    }
+  },
   "remoteServer": {
     "authError": "Authorization failed: {{error}}",
     "authPending": "Please complete the authorization in your browser",

package/locales/en-US/setting.json

@@ -520,6 +520,7 @@
     "hotkey": "Hotkeys",
     "llm": "Language Model",
     "provider": "AI Service Provider",
+    "proxy": "Network Proxy",
     "storage": "Data Storage",
     "sync": "Cloud Sync",
     "system-agent": "System Assistant",