@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/proxy/evol/presenter/configPresenter.py

@@ -1,3 +1,10 @@
+"""
+configPresenter - Proxy 模块适配版
+
+存储路径改用 KITE_MODULE_DATA，移除对 userPresenter/workPresenter 的依赖。
+保留 proxy 需要的配置读取方法。
+"""
+
 import json
 import os
 import threading
@@ -5,35 +12,40 @@ import time
 
 from ..log import logger
 
+
 class configPresenter:
     _lock = threading.Lock()
-    _config_dir_initialized = False 
+    _config_dir_initialized = False
     searchPreviewEnabled = False
     userName = "default"
-    KEY_CLAUDE_AGENT_NAME = "claude_agent_name" # Claude代理Agent名称
-    KEY_GEMINI_AGENT_NAME = "gemini_agent_name" # Gemini代理Agent名称
-    
+    KEY_CLAUDE_AGENT_NAME = "claude_agent_name"
+    KEY_GEMINI_AGENT_NAME = "gemini_agent_name"
+
+    # 代理模式下的 evol_token（由 auth_bridge 注入）
+    _evol_token = None
+    _evol_token_lock = threading.Lock()
+
     @staticmethod
     def get_config_dir():
-        """获取配置文件目录，确保PyInstaller打包后也能正常工作"""
-        import platform
+        """获取配置目录：优先使用 KITE_MODULE_DATA"""
+        module_data = os.environ.get("KITE_MODULE_DATA", "")
+        if module_data:
+            return os.path.join(module_data, "config")
 
+        import platform
         if platform.system() == "Windows":
-            app_path = os.path.join(os.getenv("APPDATA", "~"), "evol",configPresenter.userName)
+            app_path = os.path.join(os.getenv("APPDATA", "~"), "evol", configPresenter.userName)
         else:
             home_dir = os.path.expanduser("~")
             if os.access(home_dir, os.W_OK):
-                app_path = os.path.join(home_dir, ".evol",configPresenter.userName)
-
+                app_path = os.path.join(home_dir, ".evol", configPresenter.userName)
             else:
                 import tempfile
-                app_path = os.path.join(tempfile.gettempdir(), "evol",configPresenter.userName)
-        logger.debug(f"using config dir: {app_path}")
+                app_path = os.path.join(tempfile.gettempdir(), "evol", configPresenter.userName)
         return app_path
 
     @staticmethod
     def ensure_config_dir():
-        """确保配置目录存在，只在需要时创建一次"""
         if not configPresenter._config_dir_initialized:
             config_dir = configPresenter.get_config_dir()
             try:
@@ -41,149 +53,89 @@ class configPresenter:
                 configPresenter._config_dir_initialized = True
             except Exception as e:
                 print(f"创建配置目录失败: {e}")
-                # 降级到临时目录
-                import tempfile
-
-                config_dir = tempfile.gettempdir()
         return True
-    
+
     @staticmethod
     def get_claude_agent_name():
-        """获取Claude智能体名称"""
-        """获取Claude代理Agent名称，如果未设置则返回默认值"""
-        #return "claude_code_proxy.aid.pub"
         agent_name = configPresenter.getSetting(configPresenter.KEY_CLAUDE_AGENT_NAME)
         if agent_name is None:
-            return "claude_code_proxy_1.aid.pub"  # 默认值
-            #return "claude_code_proxy.aid.pub"
+            return "claude_code_proxy_1.aid.pub"
         return agent_name
 
     @staticmethod
     def get_gemini_agent_name():
-        """获取Gemini智能体名称"""
-        """获取Gemini代理Agent名称，如果未设置则返回默认值"""
         agent_name = configPresenter.getSetting(configPresenter.KEY_GEMINI_AGENT_NAME)
         if agent_name is None:
-            return "gemini_proxy.aid.pub"  # 默认值
+            return "gemini_proxy.aid.pub"
         return agent_name
 
-
     @staticmethod
-    def get_config_file_path(workspaceName = ""):
-        """获取配置文件的完整路径"""
-        if not workspaceName:
-            configPresenter.ensure_config_dir()  # 确保目录存在
-            config_dir = configPresenter.get_config_dir()
-            return os.path.join(config_dir, "key_value_store.json")
-        else:
-            from evol.presenter.workPresenter import workPresenter
-            workspace = workPresenter.get_evol_workspace_path(workspaceName)
-            return os.path.join(workspace, "key_value_store.json")
+    def get_config_file_path(workspaceName=""):
+        configPresenter.ensure_config_dir()
+        config_dir = configPresenter.get_config_dir()
+        return os.path.join(config_dir, "key_value_store.json")
 
     @staticmethod
-    def getSetting(key,workspaceName = ""):
-        """
-        从本地文件读取指定键的值
-        """
+    def getSetting(key, workspaceName=""):
         filepath = configPresenter.get_config_file_path(workspaceName)
         try:
             with open(filepath, "r", encoding="utf-8") as f:
                 content = f.read().strip()
-                if not content:  # 如果文件为空
+                if not content:
                     return None
                 data = json.loads(content)
-                value = data.get(key)
-                return value
+                return data.get(key)
         except FileNotFoundError:
             return None
-        except json.JSONDecodeError as e:
-            logger.error(f"JSON格式错误: {e}")
-            # 如果JSON格式错误，重新创建一个空的配置文件
+        except json.JSONDecodeError:
             try:
                 with open(filepath, "w", encoding="utf-8") as f:
                     json.dump({}, f, indent=4, ensure_ascii=False)
-                logger.info("已重新创建配置文件")
-            except Exception as write_error:
-                logger.error(f"重新创建配置文件失败: {write_error}")
+            except Exception:
+                pass
             return None
-        except Exception as e:
-            logger.exception(f"读取设置时出错: {e}")
+        except Exception:
             return None
 
     @staticmethod
-    def setSetting(key, value,workspaceName = ""):
-        """
-        将键值对存储到本地文件（线程安全版本）
-        """
-        logger.info(f"开始保存设置: {key} = {value}")
+    def setSetting(key, value, workspaceName=""):
         try:
-            with configPresenter._lock:  # 使用线程锁保护临界区
+            with configPresenter._lock:
                 filepath = configPresenter.get_config_file_path(workspaceName)
                 if not os.path.exists(filepath):
                     with open(filepath, "w", encoding="utf-8") as f:
                         json.dump({}, f, indent=4, ensure_ascii=False)
 
-                # 读取现有数据
                 try:
                     with open(filepath, "r", encoding="utf-8") as f:
                         data = json.load(f)
                 except (json.JSONDecodeError, FileNotFoundError):
                     data = {}
 
-                # 更新数据
-                old_value = data.get(key, "未设置")
                 data[key] = value
 
-                # 写回文件
                 with open(filepath, "w", encoding="utf-8") as f:
                     json.dump(data, f, indent=4, ensure_ascii=False)
         except Exception as e:
             logger.exception(f"保存设置时出错: {e}")
             return False
         return True
-    
-    @staticmethod
-    def setCurrentModelInfo(workspaceName,modelId,providerId):
-        configPresenter.setSetting("currentModel", modelId,workspaceName)
-        configPresenter.setSetting("currentProvider", providerId,workspaceName)
-    
-    @staticmethod
-    def getCurrentModelInfo(workspaceName):
-        currentModel = configPresenter.getSetting("currentModel",workspaceName)
-        currentProvider = configPresenter.getSetting("currentProvider",workspaceName)
-        return {"modelId": currentModel, "providerId": currentProvider}
-
-    @staticmethod
-    def setProviderById(key,value):
-        pass
-    
-    @staticmethod
-    def deleteProviders(id):
-        pass
 
     @staticmethod
-    def addProviders(value):
-        pass
-        
-    @staticmethod
-    def get_fsss2_file_path():
-        """获取fsss2文件的完整路径（用于存储token）"""
-        configPresenter.ensure_config_dir()
-        config_dir = configPresenter.get_config_dir()
-        return os.path.join(config_dir, "fsss2")
+    def set_evol_token(token: str):
+        """由 auth_bridge 注入 evol_token"""
+        with configPresenter._evol_token_lock:
+            configPresenter._evol_token = token
 
     @staticmethod
     def get_token():
-        """
-        获取token（优先从fsss2文件读取）
-        读取逻辑：
-        1. 先读取fsss2文件
-        2. 如果没读取到，再读取原来位置的token
-        3. 如果原位置有token，写入fsss2文件再返回
-        """
-        fsss2_path = configPresenter.get_fsss2_file_path()
+        """获取 token - 优先从 auth_bridge 注入的值获取"""
+        with configPresenter._evol_token_lock:
+            if configPresenter._evol_token:
+                return configPresenter._evol_token
 
-        # 1. 先尝试从fsss2文件读取
+        # 回退到文件
+        fsss2_path = configPresenter.get_fsss2_file_path()
         try:
             with open(fsss2_path, "r", encoding="utf-8") as f:
                 token = f.read().strip()
@@ -191,1091 +143,92 @@ class configPresenter:
                     return token
         except FileNotFoundError:
             pass
-        except Exception as e:
-            logger.error(f"读取fsss2文件时出错: {e}")
-
-        # 2. fsss2没读到，尝试从原位置读取
-        old_token = configPresenter.getSetting("token")
-        if old_token:
-            # 3. 原位置有token，写入fsss2文件
-            try:
-                with open(fsss2_path, "w", encoding="utf-8") as f:
-                    f.write(old_token)
-                logger.info("已将token从原位置迁移到fsss2文件")
-            except Exception as e:
-                logger.error(f"迁移token到fsss2文件时出错: {e}")
-            return old_token
+        except Exception:
+            pass
 
-        return None
+        return configPresenter.getSetting("token")
 
     @staticmethod
     def set_token(token: str):
-        """
-        设置token（写入fsss2文件）
-        如果token为空或None，删除fsss2文件以清除token
-        """
         fsss2_path = configPresenter.get_fsss2_file_path()
-
-        # 如果token为空，删除文件以清除token
         if not token:
             try:
                 if os.path.exists(fsss2_path):
                     os.remove(fsss2_path)
-                    logger.info("token已清除（fsss2文件已删除）")
                 return True
-            except Exception as e:
-                logger.exception(f"清除token时出错: {e}")
+            except Exception:
                 return False
 
         try:
             with open(fsss2_path, "w", encoding="utf-8") as f:
                 f.write(token)
-            logger.info("token已保存到fsss2文件")
             return True
-        except Exception as e:
-            logger.exception(f"保存token到fsss2文件时出错: {e}")
-            return False
-
-    @staticmethod
-    def set_account_info(username: str, password: str):
-        account_info = {"username": username, "password": password}
-        return configPresenter.setSetting("account_info", json.dumps(account_info))
-
-    @staticmethod
-    def get_account_info():
-        try:
-            user_info = configPresenter.getSetting("account_info")
-            if user_info is None:
-                return None
-            return json.loads(user_info)
-        except:
-            return None
-
-    @staticmethod
-    def set_user_info(aid: str, password: str):
-        user_info = {"aid": aid, "password": password}
-        return configPresenter.setSetting("user_info", json.dumps(user_info))
-
-    @staticmethod
-    def get_user_info():
-        try:
-            user_info = configPresenter.getSetting("user_info")
-            if user_info is None:
-                return None
-            return json.loads(user_info)
-        except:
-            return None
-
-    @staticmethod
-    def getSearchPreviewEnabled():
-        return configPresenter.searchPreviewEnabled
-    
-    @staticmethod
-    def getCustomSearchEngines():
-        return 'baidu'
-    
-    @staticmethod   
-    def getProviders():
-        return []
-        
-    @staticmethod        
-    def getDefaultProviders():
-        return ""
-        
-    @staticmethod    
-    def getLanguage():
-        return "zh-CN"
-    
-    @staticmethod
-    def getModelDefaultConfig(modal):
-        return "";
-    
-    @staticmethod
-    def getArtifactsEffectEnabled():
-        return False
-    
-    @staticmethod
-    def setProviderById(key,value):
-        pass
-    
-    @staticmethod
-    def deleteProviders(id):
-        pass
-
-    @staticmethod
-    def addProviders(value):
-        pass
-        
-    @staticmethod
-    def is_autostart_enabled():
-        return False
-
-    @staticmethod
-    def disable_autostart():
-        return False
-
-    @staticmethod
-    def enable_autostart():
-        return False
-
-    @staticmethod
-    def get_statistics_cache(workspace_name: str):
-        """
-        获取工作空间统计数据缓存
-
-        Args:
-            workspace_name (str): 工作空间名称
-
-        Returns:
-            dict: 缓存数据，包含timestamp和data字段，如果没有缓存则返回None
-        """
-        cache_key = f"statistics_cache_{workspace_name}"
-        return configPresenter.getSetting(cache_key, workspace_name)
-
-    @staticmethod
-    def set_statistics_cache(workspace_name: str, statistics_data: dict):
-        """
-        设置工作空间统计数据缓存
-
-        Args:
-            workspace_name (str): 工作空间名称
-            statistics_data (dict): 统计数据
-
-        Returns:
-            bool: 是否设置成功
-        """
-        cache_key = f"statistics_cache_{workspace_name}"
-        cache_data = {
-            "timestamp": time.time(),
-            "data": statistics_data
-        }
-        return configPresenter.setSetting(cache_key, cache_data, workspace_name)
-
-    @staticmethod
-    def is_statistics_cache_valid(workspace_name: str, cache_timeout: int = 300):
-        """
-        检查统计数据缓存是否有效（默认5分钟过期）
-
-        Args:
-            workspace_name (str): 工作空间名称
-            cache_timeout (int): 缓存超时时间（秒），默认300秒（5分钟）
-
-        Returns:
-            bool: 缓存是否有效
-        """
-        cache_data = configPresenter.get_statistics_cache(workspace_name)
-        if not cache_data or not isinstance(cache_data, dict):
-            return False
-
-        timestamp = cache_data.get("timestamp")
-        if not timestamp:
-            return False
-
-        current_time = time.time()
-        return (current_time - timestamp) < cache_timeout
-
-    @staticmethod
-    def get_default_download_path():
-        """
-        获取系统默认下载路径
-
-        Returns:
-            str: 默认下载路径
-        """
-        import platform
-
-        if platform.system() == "Windows":
-            # Windows系统下载路径
-            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
-        elif platform.system() == "Darwin":  # macOS
-            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
-        else:  # Linux
-            downloads_path = os.path.join(os.path.expanduser("~"), "Downloads")
-
-        # 确保路径存在
-        if not os.path.exists(downloads_path):
-            try:
-                os.makedirs(downloads_path, exist_ok=True)
-            except Exception as e:
-                logger.error(f"创建下载目录失败: {e}")
-                # 降级到用户主目录
-                downloads_path = os.path.expanduser("~")
-
-        return downloads_path
-
-    @staticmethod
-    def get_download_path():
-        """
-        获取下载路径设置，如果没有设置则返回系统默认下载路径
-
-        Returns:
-            str: 下载路径
-        """
-        download_path = configPresenter.getSetting("download_path")
-        if not download_path:
-            # 如果没有设置，获取系统默认下载路径并保存
-            default_path = configPresenter.get_default_download_path()
-            configPresenter.set_download_path(default_path)
-            return default_path
-        return download_path
-
-    @staticmethod
-    def set_download_path(path: str):
-        """
-        设置下载路径
-
-        Args:
-            path (str): 下载路径
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting("download_path", path)
-
-    # ============ 默认工作空间路径配置 ============
-
-    @staticmethod
-    def get_default_workspace_path():
-        """
-        获取默认工作空间路径
-
-        Returns:
-            str: 默认工作空间路径，如果未设置则返回None
-        """
-        return configPresenter.getSetting("default_workspace_path")
-
-    @staticmethod
-    def get_default_workspace_base_path():
-        """
-        获取默认工作空间基础路径（系统默认路径）
-
-        Returns:
-            str: 默认工作空间基础路径
-        """
-        return os.path.join(configPresenter.get_config_dir(), "workspace")
-
-    @staticmethod
-    def set_default_workspace_path(path: str):
-        """
-        设置默认工作空间路径
-
-        Args:
-            path (str): 默认工作空间路径
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting("default_workspace_path", path)
-
-    # ============ AI 网关配置管理 ============
-
-    KEY_AI_GATEWAY_TYPE = "ai_gateway_type"
-    KEY_AI_GATEWAY_CONFIGS = "ai_gateway_configs"
-
-    # 默认网关配置
-    DEFAULT_GATEWAY_CONFIGS = {
-        "local": {
-            "type": "local",
-            "name": "本地网关",
-            "description": "使用本地 ModelGate 服务",
-            "baseUrl": "http://127.0.0.1:13148",
-            "apiVersion": "/v1",
-            "timeout": 30000,
-            "retryCount": 3,
-            "enabled": True
-        },
-        "cloud": {
-            "type": "cloud",
-            "name": "Evol 网关",
-            "description": "使用 Evol 云端服务",
-            # 兜底配置，实际云端地址会由 userPresenter 的网关信息覆盖
-            "baseUrl": "https://mg-new.evolai.cn",
-            "apiVersion": "/v1",
-            "timeout": 30000,
-            "retryCount": 3,
-            "enabled": True
-        }
-    }
-
-    @staticmethod
-    def get_gateway_type():
-        """
-        获取当前网关类型
-
-        Returns:
-            str: 'local' 或 'cloud'，默认 'cloud'
-        """
-        gateway_type = configPresenter.getSetting(configPresenter.KEY_AI_GATEWAY_TYPE)
-        if not gateway_type:
-            # 默认使用云端网关
-            configPresenter.set_gateway_type("cloud")
-            return "cloud"
-        return gateway_type
-
-    @staticmethod
-    def set_gateway_type(gateway_type: str):
-        """
-        设置当前网关类型
-
-        Args:
-            gateway_type (str): 'local', 'cloud', 或 'custom-{id}'
-
-        Returns:
-            bool: 是否设置成功
-        """
-        # 验证网关类型
-        if gateway_type in ["local", "cloud"]:
-            # 预设网关，直接设置
-            logger.info(f"Setting gateway type to: {gateway_type}")
-            return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_TYPE, gateway_type)
-        elif gateway_type.startswith("custom-"):
-            # 自定义网关，验证是否存在
-            gateway_id = gateway_type.replace("custom-", "")
-            custom_gateway = configPresenter.get_custom_gateway(gateway_id)
-            if custom_gateway:
-                logger.info(f"Setting gateway type to custom: {gateway_id}")
-                return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_TYPE, gateway_type)
-            else:
-                logger.error(f"Custom gateway not found: {gateway_id}")
-                return False
-        else:
-            logger.error(f"Invalid gateway type: {gateway_type}")
-            return False
-
-    @staticmethod
-    def get_gateway_configs():
-        """
-        获取所有网关配置
-
-        Returns:
-            dict: 所有网关配置
-        """
-        #configs = configPresenter.getSetting(configPresenter.KEY_AI_GATEWAY_CONFIGS)
-        #if not configs:
-            # 首次使用，保存默认配置
-        configPresenter.set_gateway_configs(configPresenter.DEFAULT_GATEWAY_CONFIGS)
-        return configPresenter.DEFAULT_GATEWAY_CONFIGS
-        #return configs
-
-    @staticmethod
-    def _apply_cloud_gateway_info(config: dict) -> dict:
-        if not isinstance(config, dict):
-            return config
-
-        try:
-            from .userPresenter import userPresenter
-
-            result = userPresenter.get_cloud_gateway_info()
-            gateway_info = None
-            if isinstance(result, dict):
-                gateway_info = result.get("gateway_info")
-
-            if isinstance(gateway_info, dict):
-                base_url = gateway_info.get("modelBaseUrl") or gateway_info.get("apiUrl")
-                if base_url:
-                    updated = dict(config)
-                    updated["baseUrl"] = base_url
-                    return updated
         except Exception:
-            return config
-
-        return config
-
-    @staticmethod
-    def set_gateway_configs(configs: dict):
-        """
-        设置所有网关配置
-
-        Args:
-            configs (dict): 网关配置字典
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting(configPresenter.KEY_AI_GATEWAY_CONFIGS, configs)
-
-    @staticmethod
-    def get_gateway_config(gateway_type: str = None):
-        """
-        获取指定网关的配置（支持自定义网关）
-
-        Args:
-            gateway_type (str): 网关类型，不传则使用当前网关
-
-        Returns:
-            dict: 网关配置
-        """
-        if not gateway_type:
-            gateway_type = configPresenter.get_gateway_type()
-
-        # 检查是否为自定义网关
-        if gateway_type and gateway_type.startswith("custom-"):
-            gateway_id = gateway_type.replace("custom-", "")
-            custom_config = configPresenter.get_custom_gateway(gateway_id)
-            if custom_config:
-                logger.debug(f"Using custom gateway config: {gateway_id}")
-                return custom_config
-            else:
-                logger.warning(f"Custom gateway not found: {gateway_id}, using default cloud gateway")
-                return configPresenter.DEFAULT_GATEWAY_CONFIGS.get("cloud", {})
-
-        # 原有逻辑：本地或云端网关
-        configs = configPresenter.get_gateway_configs()
-        config = configs.get(gateway_type)
-
-        if not config:
-            logger.warning(f"Gateway config not found: {gateway_type}, using default")
-            return configPresenter.DEFAULT_GATEWAY_CONFIGS.get(gateway_type, {})
-
-        if gateway_type == "cloud":
-            return configPresenter._apply_cloud_gateway_info(config)
-
-        return config
-
-    @staticmethod
-    def get_current_gateway_base_url():
-        """
-        获取当前网关的 Base URL
-
-        Returns:
-            str: 当前网关的基础 URL
-        """
-        config = configPresenter.get_gateway_config()
-        return config.get("baseUrl", "http://127.0.0.1:13148")
-
-    @staticmethod
-    def get_current_gateway_api_url():
-        """
-        获取当前网关的 API URL（含版本）
-
-        Returns:
-            str: 当前网关的 API URL
-        """
-        config = configPresenter.get_gateway_config()
-        base_url = config.get("baseUrl", "http://127.0.0.1:13148")
-        api_version = config.get("apiVersion", "/v1")
-        return f"{base_url}{api_version}"
-
-    @staticmethod
-    def get_current_gateway_api_key():
-        """
-        获取当前网关的 API Key
-
-        Returns:
-            str: 当前网关的 API Key，如果没有则返回空字符串
-        """
-        config = configPresenter.get_gateway_config()
-        return config.get("apiKey", "")
-
-    @staticmethod
-    def build_gateway_url(endpoint: str, include_version: bool = True, gateway_type: str = None):
-        """
-        构建完整的网关端点 URL
-
-        Args:
-            endpoint (str): 端点路径
-            include_version (bool): 是否包含版本号
-            gateway_type (str): 网关类型，不传则使用当前网关
-
-        Returns:
-            str: 完整的 URL
-        """
-        config = configPresenter.get_gateway_config(gateway_type)
-        base_url = config.get("baseUrl", "http://127.0.0.1:13148")
-
-        if include_version:
-            api_version = config.get("apiVersion", "/v1")
-            base = f"{base_url}{api_version}"
-        else:
-            base = base_url
-
-        # 确保 endpoint 以 / 开头
-        if not endpoint.startswith("/"):
-            endpoint = f"/{endpoint}"
-
-        return f"{base}{endpoint}"
-
-    # ============ 自定义网关管理 ============
-
-    KEY_CUSTOM_GATEWAYS = "custom_gateways"
-
-    @staticmethod
-    def get_custom_gateways():
-        """
-        获取所有自定义网关配置
-
-        Returns:
-            dict: 自定义网关配置字典，格式为 {gateway_id: config}
-        """
-        gateways = configPresenter.getSetting(configPresenter.KEY_CUSTOM_GATEWAYS)
-        return gateways if gateways else {}
-
-    @staticmethod
-    def add_custom_gateway(config=None):
-        """
-        添加自定义网关
-
-        Args:
-            config (dict): 网关配置，包含 name, baseUrl, apiKey, apiType 等字段
-
-        Returns:
-            dict: {"success": bool, "id": str} 添加结果
-        """
-        import uuid
-
-        try:
-            logger.info(f"add_custom_gateway called with config: {config}")
-            logger.info(f"config type: {type(config)}")
-
-            if config is None:
-                logger.error("Config is None!")
-                return {"success": False, "id": "", "error": "Config is None"}
-
-            if not isinstance(config, dict):
-                logger.error(f"Config is not a dict, it's {type(config)}")
-                return {"success": False, "id": "", "error": f"Config must be dict, got {type(config)}"}
-
-            # 生成唯一ID
-            gateway_id = str(uuid.uuid4())[:8]
-
-            gateways = configPresenter.get_custom_gateways()
-
-            # 根据API类型确定API版本
-            api_type = config.get("apiType", "openai")
-            api_version = "/v1"  # OpenAI风格默认使用 /v1
-
-            # 构建完整的网关配置
-            gateways[gateway_id] = {
-                "id": gateway_id,
-                "type": f"custom-{gateway_id}",
-                "name": config.get("name", "自定义网关"),
-                "description": config.get("description", f"自定义网关 - {config.get('baseUrl', '')}"),
-                "baseUrl": config.get("baseUrl", ""),
-                "apiKey": config.get("apiKey", ""),
-                "apiType": api_type,
-                "apiVersion": api_version,  # 根据API类型自动设置
-                "timeout": config.get("timeout", 30000),
-                "retryCount": config.get("retryCount", 3),
-                "enabled": True,
-                "isCustom": True,
-                "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ")
-            }
-
-            success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
-
-            if success:
-                logger.info(f"Added custom gateway: {gateway_id} - {config.get('name')} (API Type: {api_type})")
-            else:
-                logger.error(f"Failed to add custom gateway: {config.get('name')}")
-
-            return {"success": success, "id": gateway_id}
-        except Exception as e:
-            logger.exception(f"Exception in add_custom_gateway: {e}")
-            return {"success": False, "id": "", "error": str(e)}
-
-    @staticmethod
-    def update_custom_gateway(gateway_id: str, config: dict):
-        """
-        更新自定义网关配置
-
-        Args:
-            gateway_id (str): 网关ID
-            config (dict): 要更新的配置字段
-
-        Returns:
-            bool: 是否更新成功
-        """
-        gateways = configPresenter.get_custom_gateways()
-
-        if gateway_id not in gateways:
-            logger.error(f"Custom gateway not found: {gateway_id}")
-            return False
-
-        # 保留原有的ID、类型和创建时间
-        original = gateways[gateway_id]
-
-        # 如果更新了apiType，需要更新对应的apiVersion
-        if "apiType" in config:
-            api_type = config.get("apiType", "openai")
-            config["apiVersion"] = "/v1"  # OpenAI风格使用 /v1
-
-        # 更新配置（合并新旧配置）
-        updated_config = {
-            **original,
-            **config,
-            "id": gateway_id,  # 确保ID不变
-            "type": f"custom-{gateway_id}",  # 确保type不变
-            "createdAt": original.get("createdAt"),  # 确保创建时间不变
-            "isCustom": True  # 确保isCustom标记不变
-        }
-
-        gateways[gateway_id] = updated_config
-
-        success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
-
-        if success:
-            logger.info(f"Updated custom gateway: {gateway_id} (API Type: {updated_config.get('apiType', 'openai')})")
-        else:
-            logger.error(f"Failed to update custom gateway: {gateway_id}")
-
-        return success
-
-    @staticmethod
-    def delete_custom_gateway(gateway_id: str):
-        """
-        删除自定义网关
-
-        Args:
-            gateway_id (str): 网关ID
-
-        Returns:
-            bool: 是否删除成功
-        """
-        gateways = configPresenter.get_custom_gateways()
-
-        if gateway_id not in gateways:
-            logger.warning(f"Custom gateway not found for deletion: {gateway_id}")
-            return False
-
-        # 检查是否正在使用该网关
-        current_gateway_type = configPresenter.get_gateway_type()
-        if current_gateway_type == f"custom-{gateway_id}":
-            logger.warning(f"Cannot delete custom gateway {gateway_id}: currently in use")
-            # 自动切换到云端网关
-            configPresenter.set_gateway_type("cloud")
-            logger.info("Switched to cloud gateway")
-
-        del gateways[gateway_id]
-
-        success = configPresenter.setSetting(configPresenter.KEY_CUSTOM_GATEWAYS, gateways)
-
-        if success:
-            logger.info(f"Deleted custom gateway: {gateway_id}")
-        else:
-            logger.error(f"Failed to delete custom gateway: {gateway_id}")
-
-        return success
-
-    @staticmethod
-    def get_custom_gateway(gateway_id: str):
-        """
-        获取指定的自定义网关配置
-
-        Args:
-            gateway_id (str): 网关ID
-
-        Returns:
-            dict: 网关配置，如果不存在则返回None
-        """
-        gateways = configPresenter.get_custom_gateways()
-        return gateways.get(gateway_id)
-
-    # ============ 应用设置配置管理 ============
-
-    KEY_APP_SETTINGS_HTTP_RULE = "app_settings_http_rule"
-
-    @staticmethod
-    def get_app_settings_http_rule():
-        """
-        获取应用设置 - 允许局域网访问配置
-
-        Returns:
-            bool: True 允许局域网访问, False 不允许（默认）
-        """
-        result = configPresenter.getSetting(configPresenter.KEY_APP_SETTINGS_HTTP_RULE)
-        if result is None:
             return False
-        # 处理字符串类型的返回值
-        if isinstance(result, str):
-            return result.lower() == 'true'
-        return bool(result)
 
     @staticmethod
-    def set_app_settings_http_rule(enabled: bool):
-        """
-        设置应用设置 - 允许局域网访问配置
-
-        Args:
-            enabled (bool): True 允许局域网访问, False 不允许
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting(configPresenter.KEY_APP_SETTINGS_HTTP_RULE, enabled)
-
-    # ============ 网络代理配置管理 ============
+    def get_fsss2_file_path():
+        configPresenter.ensure_config_dir()
+        config_dir = configPresenter.get_config_dir()
+        return os.path.join(config_dir, "fsss2")
 
-    # 类变量：内存缓存
-    _proxy_cache = None  # None 表示未加载，True/False 表示配置值
+    # 代理相关配置
+    _proxy_cache = None
     KEY_USE_SYSTEM_PROXY = "use_system_proxy"
 
     @staticmethod
     def get_use_system_proxy():
-        """
-        获取是否使用系统代理配置（优先从内存缓存读取）
-
-        Returns:
-            bool: True 表示使用系统代理, False 表示不使用（默认）
-        """
-        # 优先从缓存读取
         if configPresenter._proxy_cache is not None:
             return configPresenter._proxy_cache
-
-        # 从硬盘加载
         result = configPresenter.getSetting(configPresenter.KEY_USE_SYSTEM_PROXY)
         if result is None:
-            value = False  # 默认不使用代理
+            value = False
         elif isinstance(result, str):
             value = result.lower() == 'true'
         else:
             value = bool(result)
-
-        # 更新缓存
         configPresenter._proxy_cache = value
         return value
 
     @staticmethod
     def set_use_system_proxy(use_proxy: bool):
-        """
-        设置是否使用系统代理配置（先更新内存，再写硬盘）
-
-        Args:
-            use_proxy (bool): True 表示使用系统代理, False 表示不使用
-
-        Returns:
-            bool: 是否设置成功
-        """
-        # 1. 先更新内存缓存
         configPresenter._proxy_cache = use_proxy
-
-        # 2. 再写硬盘
         return configPresenter.setSetting(configPresenter.KEY_USE_SYSTEM_PROXY, use_proxy)
 
+    # 兼容性存根
     @staticmethod
-    def load_proxy_config():
-        """
-        启动时加载代理配置到内存（可选调用，懒加载也可以）
-
-        Returns:
-            bool: 当前的代理配置值
-        """
-        return configPresenter.get_use_system_proxy()
-
-    # ============ Tab-MCP 绑定配置管理 ============
-
-    KEY_TAB_MCP_BINDINGS = "tab_mcp_bindings"
-
-    # 默认Tab-MCP绑定配置（硬编码回退值）
-    # V1格式：字符串表示单个MCP名称
-    # 后续V2格式：对象可支持多MCP或SubAgent
-    DEFAULT_TAB_MCP_BINDINGS = {
-        "files": "Evol记忆",
-        "web": "Evol浏览器自动化",
-        "pdf": "PDF助手",
-        "excel": "Evol记忆",
-        "word": "Evol记忆",
-        "terminal": "Evol终端控制器",
-    }
+    def getSearchPreviewEnabled():
+        return False
 
     @staticmethod
-    def get_tab_mcp_bindings():
-        """
-        获取Tab-MCP绑定配置
-
-        Returns:
-            dict: Tab类型到MCP服务名称的映射，格式为 {tabType: mcpServerName}
-        """
-        bindings = configPresenter.getSetting(configPresenter.KEY_TAB_MCP_BINDINGS)
-        if not bindings or not isinstance(bindings, dict):
-            # 返回默认配置
-            return dict(configPresenter.DEFAULT_TAB_MCP_BINDINGS)
-        # 合并默认值，确保新增的tabType有默认配置
-        return {**configPresenter.DEFAULT_TAB_MCP_BINDINGS, **bindings}
+    def getCustomSearchEngines():
+        return 'baidu'
 
     @staticmethod
-    def set_tab_mcp_bindings(bindings: dict):
-        """
-        设置Tab-MCP绑定配置
-
-        Args:
-            bindings (dict): Tab类型到MCP服务名称的映射
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting(configPresenter.KEY_TAB_MCP_BINDINGS, bindings)
+    def getProviders():
+        return []
 
     @staticmethod
-    def get_mcp_for_tab_type(tab_type: str):
-        """
-        获取指定Tab类型的默认MCP服务名称
-
-        Args:
-            tab_type (str): Tab类型
-
-        Returns:
-            str: MCP服务名称，如果未配置返回空字符串
-        """
-        bindings = configPresenter.get_tab_mcp_bindings()
-        return bindings.get(tab_type, "")
+    def getDefaultProviders():
+        return ""
 
     @staticmethod
-    def set_mcp_for_tab_type(tab_type: str, mcp_server_name: str):
-        """
-        设置指定Tab类型的MCP服务
-
-        Args:
-            tab_type (str): Tab类型
-            mcp_server_name (str): MCP服务名称，空字符串表示重置为默认值
-
-        Returns:
-            bool: 是否设置成功
-        """
-        bindings = configPresenter.get_tab_mcp_bindings()
-
-        if mcp_server_name == '':
-            # 空字符串表示重置：删除该key，让默认值生效
-            bindings.pop(tab_type, None)
-        else:
-            # 设置用户自定义的MCP服务
-            bindings[tab_type] = mcp_server_name
-
-        return configPresenter.set_tab_mcp_bindings(bindings)
+    def getLanguage():
+        return "zh-CN"
 
-    # ============ 远程访问控制配置管理 ============
+    @staticmethod
+    def getModelDefaultConfig(modal):
+        return ""
 
-    KEY_REMOTE_ACCESS_ENABLED = "remote_access_enabled"
-    KEY_DISABLED_PAIRING_CODES = "disabled_pairing_codes"
+    @staticmethod
+    def getArtifactsEffectEnabled():
+        return False
 
     @staticmethod
     def get_remote_access_enabled():
-        """
-        获取远程访问总开关状态
-
-        Returns:
-            bool: True 允许远程访问, False 禁止远程访问（默认）
-        """
-        result = configPresenter.getSetting(configPresenter.KEY_REMOTE_ACCESS_ENABLED)
+        result = configPresenter.getSetting("remote_access_enabled")
         if result is None:
-            return False
+            return True  # Proxy 模块默认允许访问
         if isinstance(result, str):
             return result.lower() == 'true'
         return bool(result)
-
-    @staticmethod
-    def set_remote_access_enabled(enabled: bool):
-        """
-        设置远程访问总开关
-
-        Args:
-            enabled (bool): True 允许远程访问, False 禁止远程访问
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting(configPresenter.KEY_REMOTE_ACCESS_ENABLED, enabled)
-
-    @staticmethod
-    def get_disabled_pairing_codes():
-        """
-        获取禁用的配对码列表
-
-        Returns:
-            list: 禁用的配对码列表
-        """
-        result = configPresenter.getSetting(configPresenter.KEY_DISABLED_PAIRING_CODES)
-        if result is None:
-            return []
-        if isinstance(result, str):
-            # 支持逗号分隔的字符串格式
-            if not result.strip():
-                return []
-            return [code.strip() for code in result.split(',') if code.strip()]
-        if isinstance(result, list):
-            return result
-        return []
-
-    @staticmethod
-    def set_disabled_pairing_codes(codes: list):
-        """
-        设置禁用的配对码列表
-
-        Args:
-            codes (list): 禁用的配对码列表
-
-        Returns:
-            bool: 是否设置成功
-        """
-        return configPresenter.setSetting(configPresenter.KEY_DISABLED_PAIRING_CODES, codes)
-
-    @staticmethod
-    def add_disabled_pairing_code(code: str):
-        """
-        添加一个禁用的配对码
-
-        Args:
-            code (str): 要禁用的配对码
-
-        Returns:
-            bool: 是否添加成功
-        """
-        if not code or not code.strip():
-            return False
-        codes = configPresenter.get_disabled_pairing_codes()
-        code = code.strip()
-        if code not in codes:
-            codes.append(code)
-            return configPresenter.set_disabled_pairing_codes(codes)
-        return True
-
-    @staticmethod
-    def remove_disabled_pairing_code(code: str):
-        """
-        移除一个禁用的配对码
-
-        Args:
-            code (str): 要移除的配对码
-
-        Returns:
-            bool: 是否移除成功
-        """
-        if not code or not code.strip():
-            return False
-        codes = configPresenter.get_disabled_pairing_codes()
-        code = code.strip()
-        if code in codes:
-            codes.remove(code)
-            return configPresenter.set_disabled_pairing_codes(codes)
-        return True
-
-    @staticmethod
-    def is_pairing_code_disabled(code: str):
-        """
-        检查配对码是否被禁用
-
-        Args:
-            code (str): 配对码
-
-        Returns:
-            bool: True 表示被禁用, False 表示未被禁用
-        """
-        if not code or not code.strip():
-            return False
-        codes = configPresenter.get_disabled_pairing_codes()
-        return code.strip() in codes
-
-    @staticmethod
-    def get_remote_access_config():
-        """
-        获取远程访问配置（总开关 + 禁用的配对码）
-
-        Returns:
-            dict: {
-                "enabled": bool,
-                "disabled_codes": list
-            }
-        """
-        return {
-            "enabled": configPresenter.get_remote_access_enabled(),
-            "disabled_codes": configPresenter.get_disabled_pairing_codes()
-        }
-
-    @staticmethod
-    def set_remote_access_config(enabled: bool = None, disabled_codes: list = None):
-        """
-        设置远程访问配置
-
-        Args:
-            enabled (bool): 总开关状态（可选）
-            disabled_codes (list): 禁用的配对码列表（可选）
-
-        Returns:
-            dict: {"success": bool, "message": str}
-        """
-        try:
-            if enabled is not None:
-                configPresenter.set_remote_access_enabled(enabled)
-            if disabled_codes is not None:
-                configPresenter.set_disabled_pairing_codes(disabled_codes)
-            return {"success": True, "message": "配置已更新"}
-        except Exception as e:
-            return {"success": False, "message": str(e)}
-
-    # ============ 用户默认系统提示词配置管理 ============
-
-    KEY_USER_DEFAULT_SYSTEM_PROMPT = "user_default_system_prompt"
-
-    @staticmethod
-    def get_user_default_system_prompt(workspace_name: str):
-        """
-        获取用户默认系统提示词(workspace级别)
-
-        Args:
-            workspace_name (str): 任务空间名称
-
-        Returns:
-            dict: 提示词数据字典 {'userCustom': str, 'version': str}，如果未设置返回默认值
-        """
-        try:
-            prompt_data = configPresenter.getSetting(
-                configPresenter.KEY_USER_DEFAULT_SYSTEM_PROMPT,
-                workspace_name
-            )
-
-            if not prompt_data:
-                # 返回默认值
-                return {'userCustom': '', 'version': '1.0'}
-
-            # 兼容旧格式(字符串)
-            if isinstance(prompt_data, str):
-                try:
-                    return json.loads(prompt_data)
-                except json.JSONDecodeError:
-                    # 如果不是JSON,当作纯文本处理
-                    return {'userCustom': prompt_data, 'version': '1.0'}
-
-            # 新格式(字典)
-            return prompt_data
-        except Exception as e:
-            logger.exception(f"获取用户默认系统提示词失败: {e}")
-            return {'userCustom': '', 'version': '1.0'}
-
-    @staticmethod
-    def set_user_default_system_prompt(workspace_name: str, prompt_data: dict):
-        """
-        设置用户默认系统提示词(workspace级别)
-
-        Args:
-            workspace_name (str): 任务空间名称
-            prompt_data (dict): 提示词数据 {'userCustom': str, 'version': str}
-
-        Returns:
-            bool: 是否设置成功
-        """
-        try:
-            if not isinstance(prompt_data, dict):
-                logger.error(f"prompt_data必须是字典类型,当前类型: {type(prompt_data)}")
-                return False
-
-            # 确保包含必要字段
-            if 'userCustom' not in prompt_data:
-                prompt_data['userCustom'] = ''
-            if 'version' not in prompt_data:
-                prompt_data['version'] = '1.0'
-
-            success = configPresenter.setSetting(
-                configPresenter.KEY_USER_DEFAULT_SYSTEM_PROMPT,
-                prompt_data,
-                workspace_name
-            )
-
-            if success:
-                logger.info(f"已保存用户默认系统提示词到workspace: {workspace_name}")
-            else:
-                logger.error(f"保存用户默认系统提示词失败: {workspace_name}")
-
-            return success
-        except Exception as e:
-            logger.exception(f"设置用户默认系统提示词失败: {e}")
-            return False
-