@agentunion/kite 1.5.0 → 1.6.1

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

@@ -1,477 +1,71 @@
-"""
-userPresenter - 精简版，仅保留登录和AID管理相关方法
-"""
-
-import json
-import logging
-import os
-import threading
-import uuid
-from pathlib import Path
-from typing import Optional
-
-from agentcp.agentcp import AgentID
-
-from ..config import API_BASE_URL
-from ..http.async_http import AsyncHttpClient
-from .configPresenter import configPresenter
-
-logger = logging.getLogger(__name__)
-
-try:
-    from agentcp import AgentCP
-except ImportError:
-    AgentCP = None
-
-
-class userPresenter:
-    _lock = threading.RLock()
-    _user_file_path = None
-    agentId: AgentID = None
-    _agentcp_instance = None
-    _agentcp_lock = threading.RLock()
-    _aid_initializing = False
-    phone: str = None
-    gatewayInfo = None
-
-    @classmethod
-    def _get_agentcp_instance(cls):
-        """获取持久化的 AgentCP 实例"""
-        with cls._agentcp_lock:
-            if cls._agentcp_instance is None:
-                evol_user_dir = Path.home() / ".evol"
-                evol_user_dir.mkdir(exist_ok=True)
-                cls._agentcp_instance = AgentCP(
-                    evol_user_dir,
-                    seed_password="evol_user_default_password",
-                    debug=False,
-                    run_proxy=False
-                )
-            return cls._agentcp_instance
-
-    @classmethod
-    def _cleanup_aid_before_login(cls):
-        """登录前清理当前的AID（用于切换用户登录）"""
-        with cls._agentcp_lock:
-            cls._aid_initializing = False
-            if cls.agentId is not None:
-                current_aid = cls.agentId.id
-                try:
-                    cls.agentId.offline()
-                    logger.info(f"登录前已下线旧AID: {current_aid}")
-                except Exception as e:
-                    logger.warning(f"下线旧AID失败: {e}")
-                cls.agentId = None
-
-    @classmethod
-    def _get_user_file_path(cls):
-        """获取用户信息文件路径"""
-        if cls._user_file_path is None:
-            user_home = Path.home()
-            evol_dir = user_home / ".evol"
-            evol_dir.mkdir(exist_ok=True)
-            cls._user_file_path = evol_dir / "user_info.json"
-        return cls._user_file_path
-
-    @classmethod
-    def _create_default_user_info(cls):
-        """创建默认用户信息"""
-        return {
-            "username": "evol同学",
-            "user_id": str(uuid.uuid4())
-        }
-
-    @classmethod
-    def _read_user_file(cls):
-        """读取用户信息文件"""
-        file_path = cls._get_user_file_path()
-        try:
-            if file_path.exists():
-                with open(file_path, 'r', encoding='utf-8') as f:
-                    return json.load(f)
-            else:
-                default_info = cls._create_default_user_info()
-                cls._write_user_file(default_info)
-                return default_info
-        except (json.JSONDecodeError, IOError):
-            default_info = cls._create_default_user_info()
-            cls._write_user_file(default_info)
-            return default_info
-
-    @classmethod
-    def _write_user_file(cls, user_info):
-        """写入用户信息文件"""
-        file_path = cls._get_user_file_path()
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(user_info, f, ensure_ascii=False, indent=2)
-
-    @classmethod
-    def get_user_info(cls):
-        """获取用户信息"""
-        try:
-            with cls._lock:
-                user_info = cls._read_user_file()
-                return {
-                    "status": "success",
-                    "user_info": user_info
-                }
-        except Exception as e:
-            return {
-                "status": "error",
-                "error": f"获取用户信息失败: {str(e)}"
-            }
-
-    @classmethod
-    def is_logged_in(cls):
-        """判断用户是否已登录"""
-        token = configPresenter.get_token()
-        return token is not None and token != ""
-
-    @classmethod
-    async def send_sms_code(cls, phone: str, code_type: str = "LOGIN"):
-        """
-        发送验证码
-
-        Args:
-            phone: 手机号
-            code_type: 验证码类型 (LOGIN, REGISTER, RESET_PWD)
-        """
-        try:
-            url = f"{API_BASE_URL}/api/auth/sms/send"
-            data = {
-                "phone": phone,
-                "codeType": code_type
-            }
-            response = await AsyncHttpClient.post(url, data=data, include_token=False)
-
-            if response.get("code") == 200:
-                return {"status": "success", "data": response}
-            else:
-                return {
-                    "status": "error",
-                    "error": response.get("msg", "发送验证码失败")
-                }
-        except Exception as e:
-            error_msg = str(e)
-            if "ssl" in error_msg.lower():
-                return {
-                    "status": "error",
-                    "error": "网络连接失败：SSL证书验证错误。"
-                }
-            return {
-                "status": "error",
-                "error": f"发送验证码失败: {error_msg}"
-            }
-
-    @classmethod
-    def _get_device_id(cls) -> str:
-        """获取设备ID"""
-        import uuid as uuid_module
-
-        device_id = configPresenter.getSetting("device_id")
-        if device_id and not device_id.startswith("mac_"):
-            return device_id
-
-        device_id = f"uuid_{uuid_module.uuid4().hex}"
-        configPresenter.setSetting("device_id", device_id)
-        return device_id
-
-    @classmethod
-    async def sms_login(cls, phone: str, code: str):
-        """
-        验证码登录
-
-        Args:
-            phone: 手机号
-            code: 验证码
-        """
-        try:
-            cls._cleanup_aid_before_login()
-
-            url = f"{API_BASE_URL}/api/auth/sms/login"
-            data = {
-                "phone": phone,
-                "code": code,
-                "source": "evol_client",
-                "deviceId": cls._get_device_id()
-            }
-
-            response = await AsyncHttpClient.post(url, data=data, include_token=False)
-
-            if response.get("code") == 200 and response.get("data"):
-                data_obj = response.get("data")
-                token = data_obj.get("token")
-                user_info = data_obj.get("userInfo")
-
-                if token and user_info:
-                    configPresenter.set_token(token)
-
-                    with cls._lock:
-                        local_user_info = {
-                            "username": user_info.get("nickName") or user_info.get("userName"),
-                            "user_id": str(user_info.get("userId")),
-                            "phone": user_info.get("phone"),
-                            "avatar": user_info.get("avatar"),
-                        }
-                        teams = data_obj.get("teams", [])
-                        if teams:
-                            local_user_info["teams"] = [
-                                {
-                                    "team_id": team.get("teamId"),
-                                    "team_name": team.get("teamName"),
-                                    "member_role": team.get("memberRole"),
-                                }
-                                for team in teams
-                            ]
-                        cls._write_user_file(local_user_info)
-
-                # AID 初始化
-                aid_login_result = await cls.user_agent_login()
-                if aid_login_result.get("status") != "success":
-                    logger.warning(f"用户登录成功，但AID初始化失败: {aid_login_result.get('error')}")
-
-            return {"status": "success", "data": response}
-        except Exception as e:
-            return {"status": "error", "error": f"登录失败: {str(e)}"}
-
-    @classmethod
-    async def user_agent_login(cls):
-        """用户AID登录，确保AID和服务器绑定一致"""
-        try:
-            if not cls.is_logged_in():
-                return {
-                    "status": "error",
-                    "error": "用户未登录，请先登录",
-                    "error_code": 401
-                }
-
-            logger.info("开始AID登录流程")
-
-            aid_result = await cls._get_user_aid_info()
-
-            if aid_result["status"] == "error":
-                logger.error(f"获取AID信息失败: {aid_result['error']}")
-                return {
-                    "status": "error",
-                    "error": f"AID登录失败: {aid_result['error']}"
-                }
-            elif aid_result["data"] is None:
-                logger.info("服务器未返回AID，创建新AID")
-                return await cls._create_and_sync_aid()
-            else:
-                server_aid = aid_result["data"].get("aid")
-                logger.info(f"服务器返回AID: {server_aid}")
-                return await cls._handle_existing_aid(aid_result["data"])
-
-        except Exception as e:
-            logger.error(f"AID登录异常: {str(e)}")
-            import traceback
-            logger.error(f"异常堆栈: {traceback.format_exc()}")
-            return {"status": "error", "error": f"AID登录失败: {str(e)}"}
-
-    @classmethod
-    async def _get_user_aid_info(cls):
-        """获取用户AID信息"""
-        try:
-            url = f"{API_BASE_URL}/system/user/aid"
-            response = await AsyncHttpClient.get(url, include_token=True)
-
-            if response.get("code") == 200:
-                data = response.get("data")
-                if data and data.get("aid"):
-                    return {"status": "success", "data": data}
-                else:
-                    return {"status": "success", "data": None}
-            else:
-                return {
-                    "status": "error",
-                    "error": f"获取AID信息失败: {response.get('msg', '未知错误')}"
-                }
-        except Exception as e:
-            return {"status": "error", "error": f"获取AID信息失败: {str(e)}"}
-
-    @classmethod
-    async def _get_user_aid_detail(cls):
-        """获取用户AID详细信息"""
-        try:
-            url = f"{API_BASE_URL}/system/user/aid/detail"
-            response = await AsyncHttpClient.get(url, include_token=True)
-
-            if response.get("code") == 200 and response.get("data"):
-                return response["data"]
-            else:
-                return None
-        except Exception:
-            return None
-
-    @classmethod
-    async def _create_and_sync_aid(cls):
-        """创建AID并同步到服务器"""
-        try:
-            import time
-            import random
-
-            timestamp = int(time.time())
-            random_num = random.randint(0, 9)
-            agent_name = f"evol_{timestamp}_{random_num}"
-
-            agentcp = cls._get_agentcp_instance()
-            cls.agentId = agentcp.create_aid("aid.pub", agent_name)
-
-            if cls.agentId is None:
-                return {"status": "error", "error": "创建AID失败"}
-
-            logger.info(f"创建新AID: {cls.agentId.id}")
-
-            private_key = agentcp.read_private_key(cls.agentId.id)
-            pem_str = agentcp.read_certificate_pem(cls.agentId.id)
-
-            sync_data = {
-                "aid": cls.agentId.id,
-                "privateKey": private_key,
-                "pemStr": pem_str
-            }
-
-            sync_result = await cls._submit_aid_info(sync_data)
-            if sync_result["status"] != "success":
-                return sync_result
-
-            logger.info(f"AID已同步到服务器: {cls.agentId.id}")
-
-            cls.agentId.online()
-
-            if cls.agentId.is_online_success:
-                from evol.presenter.agentIdPresenter import evol_agentId_online
-                evol_agentId_online(cls.agentId)
-
-            from evol.server.claude_proxy_async import set_agent_id
-            set_agent_id(cls.agentId)
-
-            from evol.server.openclaw_proxy import set_openclaw_agentid
-            set_openclaw_agentid(cls.agentId)
-
-            return {
-                "status": "success",
-                "message": "AID创建并登录成功",
-                "aid": cls.agentId.id
-            }
-
-        except Exception as e:
-            logger.error(f"创建AID失败: {str(e)}")
-            return {"status": "error", "error": f"创建AID失败: {str(e)}"}
-
-    @classmethod
-    async def _handle_existing_aid(cls, aid_info):
-        """处理已存在的AID"""
-        try:
-            aid_id = aid_info.get("aid")
-            if not aid_id:
-                return {"status": "error", "error": "AID信息无效"}
-
-            logger.info(f"处理服务器返回的AID: {aid_id}")
-
-            if cls.agentId is not None and cls.agentId.id == aid_id:
-                logger.info(f"当前已加载正确的AID: {aid_id}")
-                return {"status": "success", "message": "AID已在线", "aid": aid_id}
-
-            agentcp = cls._get_agentcp_instance()
-            loaded_aid = agentcp.load_aid(aid_id)
-
-            if loaded_aid is None:
-                logger.warning(f"本地未找到AID: {aid_id}，从服务器同步")
-                return await cls._sync_aid_from_server(aid_id)
-
-            if loaded_aid.id != aid_id:
-                return {
-                    "status": "error",
-                    "error": f"AID不一致，本地: {loaded_aid.id}, 服务器: {aid_id}"
-                }
-
-            cls.agentId = loaded_aid
-            cls.agentId.online()
-
-            if cls.agentId.is_online_success:
-                from evol.presenter.agentIdPresenter import evol_agentId_online
-                evol_agentId_online(cls.agentId)
-
-            from evol.server.claude_proxy_async import set_agent_id
-            set_agent_id(cls.agentId)
-
-            from evol.server.openclaw_proxy import set_openclaw_agentid
-            set_openclaw_agentid(cls.agentId)
-
-            return {"status": "success", "message": "AID登录成功", "aid": aid_id}
-
-        except Exception as e:
-            logger.error(f"处理现有AID失败: {str(e)}")
-            return {"status": "error", "error": f"处理现有AID失败: {str(e)}"}
-
-    @classmethod
-    async def _sync_aid_from_server(cls, aid_id):
-        """从服务器同步AID数据到本地"""
-        try:
-            logger.info(f"从服务器同步AID: {aid_id}")
-
-            aid_detail = await cls._get_user_aid_detail()
-            if not aid_detail:
-                return {"status": "error", "error": "从服务器获取AID详细信息失败"}
-
-            if aid_detail.get("aid") != aid_id:
-                return {"status": "error", "error": "服务器返回的AID不一致"}
-
-            agentcp = cls._get_agentcp_instance()
-
-            try:
-                agentcp.get_guest_aid("aud.pub")
-            except Exception:
-                pass
-
-            agentcp.save_aid_info(
-                aid_id,
-                "evol_user_default_password",
-                aid_detail.get("privateKey", ""),
-                aid_detail.get("pemStr", "")
-            )
-
-            aid_instance = agentcp.load_aid(aid_id)
-            if aid_instance is None:
-                return {"status": "error", "error": "加载同步的AID失败"}
-
-            if aid_instance.id != aid_id:
-                return {"status": "error", "error": "加载的AID不一致"}
-
-            cls.agentId = aid_instance
-            aid_instance.online()
-
-            if aid_instance.is_online_success:
-                from evol.presenter.agentIdPresenter import evol_agentId_online
-                evol_agentId_online(aid_instance)
-
-            from evol.server.claude_proxy_async import set_agent_id
-            set_agent_id(aid_instance)
-
-            from evol.server.openclaw_proxy import set_openclaw_agentid
-            set_openclaw_agentid(aid_instance)
-
-            return {"status": "success", "message": "AID同步并登录成功", "aid": aid_id}
-
-        except Exception as e:
-            logger.error(f"同步AID失败: {str(e)}")
-            return {"status": "error", "error": f"同步AID失败: {str(e)}"}
-
-    @classmethod
-    async def _submit_aid_info(cls, aid_data):
-        """提交AID信息到服务器"""
-        try:
-            url = f"{API_BASE_URL}/system/user/aid"
-            response = await AsyncHttpClient.post(url, data=aid_data, include_token=True)
-
-            if response.get("code") == 200:
-                return {"status": "success", "message": "AID信息同步成功"}
-            else:
-                return {
-                    "status": "error",
-                    "error": f"AID信息同步失败: {response.get('msg', '未知错误')}"
-                }
-        except Exception as e:
-            return {"status": "error", "error": f"AID信息同步失败: {str(e)}"}
+"""
+userPresenter - Proxy 模块适配版
+
+薄垫片，委托给 aid_manager。
+保留 proxy_engine.py / claude_proxy_async.py 期望的接口。
+"""
+
+import json
+import os
+import threading
+import uuid
+from pathlib import Path
+from typing import Optional
+
+
+class userPresenter:
+    """兼容性垫片 - 代理代码通过此类访问 AID 和用户信息"""
+
+    _lock = threading.RLock()
+    agentId = None  # 由 aid_manager 设置
+    phone = None
+    gatewayInfo = None
+
+    # aid_manager 引用（由 ProxyServer 注入）
+    _aid_manager = None
+    _auth_bridge = None
+
+    @classmethod
+    def set_aid_manager(cls, aid_manager):
+        cls._aid_manager = aid_manager
+
+    @classmethod
+    def set_auth_bridge(cls, auth_bridge):
+        cls._auth_bridge = auth_bridge
+
+    @classmethod
+    def get_user_info(cls):
+        """获取用户信息"""
+        try:
+            module_data = os.environ.get("KITE_MODULE_DATA", "")
+            user_file = os.path.join(module_data, "config", "user_info.json") if module_data else ""
+
+            if user_file and os.path.exists(user_file):
+                with open(user_file, "r", encoding="utf-8") as f:
+                    user_info = json.load(f)
+                return {"status": "success", "user_info": user_info}
+
+            # 默认用户信息
+            return {
+                "status": "success",
+                "user_info": {
+                    "username": "proxy_user",
+                    "user_id": str(uuid.uuid4()),
+                }
+            }
+        except Exception as e:
+            return {"status": "error", "error": f"获取用户信息失败: {e}"}
+
+    @classmethod
+    def is_logged_in(cls):
+        """判断用户是否已登录"""
+        if cls._auth_bridge:
+            return cls._auth_bridge.is_logged_in()
+        from .configPresenter import configPresenter
+        token = configPresenter.get_token()
+        return token is not None and token != ""
+
+    @classmethod
+    def get_cloud_gateway_info(cls):
+        """获取云端网关信息"""
+        return {"gateway_info": cls.gatewayInfo} if cls.gatewayInfo else {}

package/extensions/services/proxy/evol/server/claude_proxy_async.py

@@ -263,7 +263,9 @@ def _full_rebuild_agentcp_system() -> bool:
         from pathlib import Path
         from agentcp import AgentCP
 
-        evol_user_dir = Path.home() / ".evol"
+        # 使用 KITE_MODULE_DATA 下的 agentcp 目录
+        module_data = os.environ.get("KITE_MODULE_DATA", "")
+        evol_user_dir = Path(os.path.join(module_data, "agentcp")) if module_data else Path.home() / ".evol"
         agentcp_dir = evol_user_dir / "agentcp" / "AIDs"
 
         if not agentcp_dir.exists():
@@ -280,11 +282,8 @@ def _full_rebuild_agentcp_system() -> bool:
 
         # 使用锁保护全局变量修改
         with _rebuild_lock:
-            # 获取旧实例引用（注意：如果步骤2失败，current_agent.online() 已经尝试过重建，
-            # 其内部会调用 close_all_session()，所以这里不需要再次关闭）
             old_agentcp = _agentcp_instance
 
-            # 清空旧引用
             agentId = None
             _agentcp_instance = None
             userPresenter.agentId = None
@@ -508,7 +507,8 @@ async def force_rebuild_agentcp_system(bypass_cooldown: bool = True) -> dict:
         from pathlib import Path
         from agentcp import AgentCP
 
-        evol_user_dir = Path.home() / ".evol"
+        module_data = os.environ.get("KITE_MODULE_DATA", "")
+        evol_user_dir = Path(os.path.join(module_data, "agentcp")) if module_data else Path.home() / ".evol"
         agentcp_dir = evol_user_dir / "agentcp" / "AIDs"
 
         if not agentcp_dir.exists():
@@ -1276,8 +1276,12 @@ def get_proxy_logger():
             from ..utils.log_paths import get_python_log_dir
             log_dir = get_python_log_dir("proxy")
         except ImportError:
-            from pathlib import Path
-            log_dir = str(Path.home() / ".evol" / "logs" / "proxy")
+            module_data = os.environ.get("KITE_MODULE_DATA", "")
+            if module_data:
+                log_dir = os.path.join(module_data, "log")
+            else:
+                from pathlib import Path
+                log_dir = str(Path.home() / ".evol" / "logs" / "proxy")
             os.makedirs(log_dir, exist_ok=True)
         from logging.handlers import RotatingFileHandler