@agentunion/kite 1.3.2 → 1.5.0

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

@@ -0,0 +1,477 @@
+"""
+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)}"}

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

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-