@agentunion/kite 1.5.0 → 1.6.1

package/extensions/services/evol/server.py

@@ -1,875 +1,2426 @@
-"""
-Evol HTTP Server
-Evol account management with full Kite module management UI.
-"""
-
-import asyncio
-import json
-import logging
-import os
-import time
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-
-import websockets
-from fastapi import FastAPI, WebSocket, Request
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, JSONResponse
-
-from extensions.services.evol.evol_api import EvolAPI
-from extensions.services.evol.auth_manager import AuthManager
-from extensions.services.evol.stats_manager import StatsManager
-from extensions.services.evol.routes.routes_rpc import router as rpc_router, set_evol_server
-from extensions.services.evol.routes.routes_management_ws import router as management_ws_router, broadcast_event
-from extensions.services.evol.routes.routes_test import router as test_router
-from extensions.services.evol.config_loader import load_business_configs
-from extensions.services.evol.pairing import PairingManager
-from extensions.services.evol.relay import KernelRelay
-
-
-def _fmt_elapsed(t0: float) -> str:
-    """Format elapsed time since t0."""
-    d = time.monotonic() - t0
-    if d < 1:
-        return f"{d * 1000:.0f}ms"
-    if d < 10:
-        return f"{d:.1f}s"
-    return f"{d:.0f}s"
-
-
-logger = logging.getLogger(__name__)
-
-# System broadcast events
-SYSTEM_BROADCAST_EVENTS = {
-    "module.ready", "module.registered", "module.started", "module.stopped",
-    "module.crashed", "module.exiting", "module.offline",
-    "module.shutdown.ack", "module.shutdown.ready",
-    "system.ready", "registry.updated",
-}
-
-
-class EvolServer:
-    def __init__(self, token: str, kernel_port: int, host: str, port: int, boot_t0: float):
-        self.token = token
-        self.kernel_port = kernel_port
-        self.host = host
-        self.port = port
-        self.boot_t0 = boot_t0
-        self._ws_task: asyncio.Task | None = None
-        self._test_task: asyncio.Task | None = None
-        self._ws: object | None = None
-        self._shutting_down = False
-        self._exit_code = 0
-        self._uvicorn_server = None
-        self._start_time = time.time()
-        self._rpc_futures = {}
-
-        # 用户信息缓存（10秒有效期）
-        self._user_info_cache = {}  # {evol_token: {"data": ..., "timestamp": ...}}
-        self._cache_ttl = 10  # 缓存有效期（秒）
-
-        # Evol business managers
-        data_dir = os.environ.get("KITE_DATA", os.path.expanduser("~/.kite/data"))
-        evol_data_dir = os.path.join(data_dir, "evol")
-        os.makedirs(evol_data_dir, exist_ok=True)
-
-        self.evol_api = EvolAPI()
-        self.auth_manager = AuthManager(evol_data_dir)
-        self.stats_manager = StatsManager(evol_data_dir, self.evol_api, self.auth_manager)
-
-        self.app = self._create_app()
-
-    def _create_app(self) -> FastAPI:
-        app = FastAPI(title="Kite Evol Module", docs_url="/docs", redoc_url=None)
-        server = self
-
-        @app.on_event("startup")
-        async def _startup():
-            # Start stats collection
-            await server.stats_manager.start()
-
-            # Load business configurations
-            module_dir = Path(__file__).parent
-            try:
-                business_configs = load_business_configs(str(module_dir))
-            except Exception as e:
-                logger.error(f"Failed to load business configs: {e}")
-                business_configs = {}
-
-            # Get relay service config
-            relay_business = business_configs.get('relay_service')
-            if relay_business:
-                try:
-                    relay_config = relay_business['config']
-
-                    # Initialize pairing manager
-                    auth_config = relay_config['auth']
-                    pairing_file = module_dir / auth_config['pairing_code_file']
-                    pairing_manager = PairingManager(
-                        pairing_file=str(pairing_file),
-                        code_length=auth_config['pairing_code_length'],
-                        token_expiry=auth_config['token_expiry']
-                    )
-                    app.state.pairing_manager = pairing_manager
-                    logger.info("Pairing manager initialized")
-
-                    # Initialize relay service
-                    relay_service = KernelRelay(
-                        kernel_host="127.0.0.1",
-                        kernel_port=server.kernel_port,
-                        kernel_token=server.token,
-                        base_module_id=relay_config['relay']['base_module_id'],
-                        reconnect_timeout=relay_config['relay']['reconnect_timeout'],
-                        permissions=relay_config['permissions'],
-                        pairing_manager=pairing_manager,
-                        evol_server=server
-                    )
-                    app.state.relay_service = relay_service
-                    logger.info("Relay service initialized")
-                except KeyError as e:
-                    logger.error(f"Missing required config field for relay_service: {e}")
-                    logger.warning("Relay service disabled due to config error")
-                except Exception as e:
-                    logger.error(f"Failed to initialize relay_service: {e}", exc_info=True)
-                    logger.warning("Relay service disabled due to initialization error")
-            else:
-                logger.info("Relay service not configured (no 'relay_service' in businesses)")
-
-            # Start background tasks
-            if server.kernel_port:
-                server._ws_task = asyncio.create_task(server._ws_loop())
-            server._test_task = asyncio.create_task(server._test_event_loop())
-
-        @app.on_event("shutdown")
-        async def _shutdown():
-            await server.stats_manager.stop()
-            if server._ws_task:
-                server._ws_task.cancel()
-            if server._test_task:
-                server._test_task.cancel()
-            if server._ws:
-                await server._ws.close()
-            print("[evol] Shutdown complete")
-
-        # Health and status endpoints
-        @app.get("/health")
-        async def health():
-            return {
-                "status": "healthy",
-                "details": {
-                    "kernel_connected": server._ws is not None,
-                    "uptime_seconds": round(time.time() - server._start_time),
-                },
-            }
-
-        @app.get("/status")
-        async def status():
-            return {
-                "module": "evol",
-                "status": "running",
-                "kernel_connected": server._ws is not None,
-                "uptime_seconds": round(time.time() - server._start_time),
-            }
-
-        # Evol API routes
-        @app.post("/api/send_sms")
-        async def send_sms(request: Request):
-            data = await request.json()
-            phone = data.get("phone", "")
-            result = await server.evol_api.send_sms(phone)
-            return JSONResponse(result)
-
-        @app.post("/api/verify_sms")
-        async def verify_sms(request: Request):
-            data = await request.json()
-            phone = data.get("phone", "")
-            code = data.get("code", "")
-            device_info = data.get("deviceInfo", {})
-
-            result = await server.evol_api.verify_sms(phone, code)
-            if not result.get("success"):
-                return JSONResponse(result)
-
-            evol_data = result["data"]
-            evol_token = evol_data.get("token", "")
-            server.auth_manager.save_evol_token(phone, evol_token, evol_data)
-
-            # 生成 Kite Token
-            kite_token = server.auth_manager.generate_kite_token(device_info)
-
-            # 绑定 Kite Token 到手机号
-            server.auth_manager.bind_kite_token_to_phone(kite_token, phone)
-
-            return JSONResponse({
-                "success": True,
-                "kiteToken": kite_token,
-                "data": {
-                    "userInfo": evol_data.get("userInfo", {}),
-                    "apiKey": evol_data.get("apiKey", ""),
-                    "credits": evol_data.get("credits", 0)
-                }
-            })
-
-        @app.post("/api/get_user_info")
-        async def get_user_info(request: Request):
-            data = await request.json()
-            kite_token = data.get("kiteToken", "")
-
-            if not server.auth_manager.verify_kite_token(kite_token):
-                return JSONResponse({
-                    "success": False,
-                    "msg": "Kite Token 无效或已过期",
-                    "code": "INVALID_TOKEN"
-                })
-
-            # 根据 Kite Token 获取绑定的手机号
-            phone = server.auth_manager.get_phone_by_kite_token(kite_token)
-            if not phone:
-                return JSONResponse({
-                    "success": False,
-                    "msg": "未登录 Evol，请先登录",
-                    "code": "NOT_LOGGED_IN"
-                })
-
-            # 根据手机号获取 Evol Token
-            evol_record = server.auth_manager.get_evol_token(phone)
-            if not evol_record:
-                return JSONResponse({
-                    "success": False,
-                    "msg": "Evol Token 已过期，请重新登录",
-                    "code": "EVOL_TOKEN_EXPIRED"
-                })
-
-            # 更新 Evol Token 使用时间（超过 1 天才记录）
-            server.auth_manager.update_evol_token_usage(phone)
-
-            evol_token = evol_record["token"]
-
-            # 检查缓存
-            now = time.time()
-            if evol_token in server._user_info_cache:
-                cached = server._user_info_cache[evol_token]
-                if now - cached["timestamp"] < server._cache_ttl:
-                    logger.info(f"Using cached user info (age: {now - cached['timestamp']:.1f}s)")
-                    return JSONResponse(cached["data"])
-
-            # 缓存未命中或已过期，从云端获取
-            result = await server.evol_api.get_user_info(evol_token)
-            if not result.get("success"):
-                return JSONResponse(result)
-
-            # 手动触发账户信息采集
-            await server.stats_manager.collect_manual()
-
-            # 统一返回格式，与 verify_sms 保持一致
-            user_data = result["data"]
-            response_data = {
-                "success": True,
-                "data": user_data  # 返回完整数据
-            }
-
-            # 更新缓存
-            server._user_info_cache[evol_token] = {
-                "data": response_data,
-                "timestamp": now
-            }
-
-            return JSONResponse(response_data)
-
-        @app.post("/api/logout")
-        async def logout(request: Request):
-            data = await request.json()
-            kite_token = data.get("kiteToken", "")
-
-            if not server.auth_manager.verify_kite_token(kite_token):
-                return JSONResponse({"success": False, "msg": "Kite Token 无效"})
-
-            # 获取绑定的手机号
-            phone = server.auth_manager.get_phone_by_kite_token(kite_token)
-
-            # 吊销 Evol Token（如果已绑定手机号）
-            if phone:
-                server.auth_manager.revoke_evol_token(phone)
-
-            # 吊销 Kite Token（解除绑定）
-            server.auth_manager.revoke_kite_token(kite_token)
-
-            return JSONResponse({"success": True, "msg": "已退出登录"})
-
-        @app.post("/api/get_credits_stats")
-        async def get_credits_stats(request: Request):
-            data = await request.json()
-            kite_token = data.get("kiteToken", "")
-            period = data.get("period", "day")
-            date = data.get("date")
-
-            if not server.auth_manager.verify_kite_token(kite_token):
-                return JSONResponse({
-                    "success": False,
-                    "msg": "Kite Token 无效或已过期",
-                    "code": "INVALID_TOKEN"
-                })
-
-            result = server.stats_manager.get_stats(period, date)
-            return JSONResponse(result)
-
-        # Mount module management routes
-        app.include_router(rpc_router, prefix="/api")
-        app.include_router(test_router, prefix="/api")
-        app.include_router(management_ws_router)  # /ws/management
-
-        # Relay WebSocket endpoint
-        @app.websocket("/ws/relay")
-        async def relay_endpoint(ws: WebSocket):
-            relay_service = getattr(app.state, 'relay_service', None)
-            if relay_service:
-                await relay_service.handle_client(ws)
-            else:
-                await ws.close(code=1011, reason="Relay service not initialized")
-
-        # Set evol server reference for RPC forwarding
-        set_evol_server(server)
-
-        # Serve frontend static files
-        static_dir = Path(__file__).parent / "static"
-        if static_dir.exists():
-            @app.get("/")
-            async def serve_index():
-                index_path = static_dir / "index.html"
-                if index_path.exists():
-                    return FileResponse(index_path)
-                return {"message": "Kite Evol Module"}
-
-            @app.get("/pairing.html")
-            async def serve_pairing():
-                pairing_path = static_dir / "pairing.html"
-                if pairing_path.exists():
-                    return FileResponse(pairing_path)
-                return JSONResponse({"error": "Not found"}, status_code=404)
-
-            @app.get("/test_registry.html")
-            async def serve_test_registry():
-                test_path = static_dir / "test_registry.html"
-                if test_path.exists():
-                    return FileResponse(test_path)
-                return JSONResponse({"error": "Not found"}, status_code=404)
-
-            @app.get("/test_relay.html")
-            async def serve_test_relay():
-                test_path = static_dir / "test_relay.html"
-                if test_path.exists():
-                    return FileResponse(test_path)
-                return JSONResponse({"error": "Not found"}, status_code=404)
-
-            app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
-
-            @app.get("/js/{file_path:path}")
-            async def serve_js(file_path: str):
-                file = static_dir / "js" / file_path
-                if file.exists() and file.is_file():
-                    return FileResponse(file)
-                return JSONResponse({"error": "Not found"}, status_code=404)
-
-            @app.get("/css/{file_path:path}")
-            async def serve_css(file_path: str):
-                file = static_dir / "css" / file_path
-                if file.exists() and file.is_file():
-                    return FileResponse(file)
-                return JSONResponse({"error": "Not found"}, status_code=404)
-
-        return app
-
-    # ── Kernel WebSocket client ──
-
-    async def _ws_loop(self):
-        retry_delay = 0.3
-        max_delay = 5.0
-        max_retries = 10
-        attempt = 0
-        while not self._shutting_down:
-            try:
-                await self._ws_connect()
-                retry_delay = 0.3
-                attempt = 0
-            except asyncio.CancelledError:
-                print(f"[evol] WS loop cancelled")
-                return
-            except Exception as e:
-                attempt += 1
-                if hasattr(e, 'rcvd') and e.rcvd is not None:
-                    code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
-                    if code in (4001, 4003):
-                        print(f"[evol] Kernel 认证失败 (code {code})，退出")
-                        self._exit_code = 1
-                        self._shutting_down = True
-                        if self._uvicorn_server:
-                            self._uvicorn_server.should_exit = True
-                        return
-                if attempt >= max_retries:
-                    print(f"[evol] Kernel 重连失败 {max_retries} 次，退出")
-                    self._exit_code = 1
-                    self._shutting_down = True
-                    if self._uvicorn_server:
-                        self._uvicorn_server.should_exit = True
-                    return
-                if self._shutting_down:
-                    return
-                print(f"[evol] Kernel connection error: {e}, retrying in {retry_delay:.1f}s ({attempt}/{max_retries})")
-            self._ws = None
-            if self._shutting_down:
-                return
-            await asyncio.sleep(retry_delay)
-            retry_delay = min(retry_delay * 2, max_delay)
-
-    async def _ws_receiver(self, ws):
-        """WebSocket 接收循环（后台任务）"""
-        try:
-            async for raw in ws:
-                try:
-                    msg = json.loads(raw)
-                except (json.JSONDecodeError, TypeError):
-                    continue
-
-                try:
-                    has_method = "method" in msg
-                    has_id = "id" in msg
-                    has_result_or_error = "result" in msg or "error" in msg
-
-                    if has_method and not has_id:
-                        await self._handle_event_notification(msg)
-                    elif has_method and has_id:
-                        asyncio.create_task(self._handle_rpc_request(ws, msg))
-                    elif has_id and has_result_or_error:
-                        rpc_id = msg.get("id")
-                        print(f"[evol] DEBUG: Received RPC response for id={rpc_id}, pending={rpc_id in self._rpc_futures}")
-                        if rpc_id in self._rpc_futures:
-                            self._rpc_futures[rpc_id].set_result(msg)
-                except Exception as e:
-                    print(f"[evol] 消息处理异常（已忽略）: {e}")
-        except Exception as e:
-            print(f"[evol] Receive loop exited with exception: {e}")
-        finally:
-            print(f"[evol] Receive loop ended")
-
-    async def _ws_connect(self):
-        url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=evol"
-        print(f"[evol] WS connecting to Kernel")
-        try:
-            async with websockets.connect(url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
-                self._ws = ws
-                elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
-                elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-                print(f"[evol] Connected to Kernel{elapsed_str}")
-
-                # 启动接收循环（后台任务）
-                receiver_task = asyncio.create_task(self._ws_receiver(ws))
-                print(f"[evol] Receiver task started")
-
-                try:
-                    # Subscribe to events
-                    await self._rpc_call("event.subscribe", {
-                        "events": [
-                            "module.started",
-                            "module.stopped",
-                            "module.crashed",
-                            "module.ready",
-                            "module.exiting",
-                            "module.shutdown",
-                            "module.shutdown.ack",
-                            "module.shutdown.ready",
-                        ],
-                    })
-
-                    # Register to Kernel
-                    await self._rpc_call("registry.register", {
-                        "module_id": "evol",
-                        "module_type": "service",
-                        "api_endpoint": f"http://127.0.0.1:{self.port}",
-                        "health_endpoint": "/health",
-                        "tools": {
-                            "rpc": {
-                                "module": {
-                                    "health": {"method": "health", "description": "健康检查"},
-                                    "status": {"method": "status", "description": "状态查询"}
-                                },
-                                "evol": {
-                                    "list_tokens": {"method": "list_tokens", "description": "列出所有令牌"},
-                                    "list_kite_tokens": {"method": "list_kite_tokens", "description": "列出 Kite 令牌"},
-                                    "list_evol_tokens": {"method": "list_evol_tokens", "description": "列出 Evol 令牌"},
-                                    "revoke_token": {"method": "revoke_token", "description": "撤销令牌"}
-                                }
-                            }
-                        },
-                        "events_publish": {
-                            "evol": {
-                                "test": {"description": "Test event from evol module"},
-                                "started": {"description": "Evol UI started with access URL"},
-                            }
-                        },
-                        "events_subscribe": [
-                            "module.started",
-                            "module.stopped",
-                            "module.crashed",
-                            "module.ready",
-                            "module.exiting",
-                            "module.shutdown",
-                            "module.shutdown.ack",
-                            "module.shutdown.ready",
-                        ],
-                    })
-                    print(f"[evol] Registered to Kernel{elapsed_str}")
-
-                    # Send module.ready
-                    if not self._shutting_down:
-                        startup_time = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
-                        await self._rpc_call("event.publish", {
-                            "event_id": str(uuid.uuid4()),
-                            "event": "module.ready",
-                            "data": {
-                                "module_id": "evol",
-                                "graceful_shutdown": True,
-                                "startup_time": startup_time,
-                            },
-                        })
-                        elapsed_str = _fmt_elapsed(self.boot_t0)
-                        print(f"[evol] module.ready published ({elapsed_str})")
-
-                        # Publish evol.started event
-                        display_host = "localhost" if self.host == "0.0.0.0" else self.host
-                        access_url = f"http://{display_host}:{self.port}"
-                        await self._publish_event({
-                            "event": "evol.started",
-                            "data": {
-                                "module_id": "evol",
-                                "url": access_url,
-                                "host": self.host,
-                                "port": self.port,
-                            },
-                        })
-
-                    # 等待接收循环结束（连接断开）
-                    await receiver_task
-                except Exception as e:
-                    # 取消接收任务
-                    receiver_task.cancel()
-                    try:
-                        await receiver_task
-                    except asyncio.CancelledError:
-                        pass
-                    raise
-        except Exception as e:
-            print(f"[evol] WebSocket connection error: {e}")
-            raise
-        finally:
-            print(f"[evol] WebSocket connection closed")
-            self._ws = None
-
-    async def _rpc_call(self, method: str, params: dict = None, timeout: float = 10.0) -> dict:
-        """Send a JSON-RPC 2.0 request and await the response."""
-        if not self._ws:
-            raise RuntimeError("WebSocket not connected")
-
-        rpc_id = str(uuid.uuid4())
-        msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
-        if params:
-            msg["params"] = params
-
-        # Create future for response
-        response_future = asyncio.Future()
-        self._rpc_futures[rpc_id] = response_future
-
-        # Send request
-        try:
-            print(f"[evol] DEBUG: Sending RPC request id={rpc_id}, method={method}")
-            await self._ws.send(json.dumps(msg))
-        except Exception as e:
-            self._rpc_futures.pop(rpc_id, None)
-            raise RuntimeError(f"Failed to send RPC request: {e}")
-
-        # Wait for response
-        try:
-            response = await asyncio.wait_for(response_future, timeout=timeout)
-        except asyncio.TimeoutError:
-            self._rpc_futures.pop(rpc_id, None)
-            raise RuntimeError(f"RPC timeout waiting for {method}")
-        finally:
-            self._rpc_futures.pop(rpc_id, None)
-
-        # Check for error
-        if "error" in response:
-            error = response["error"]
-            error_msg = error.get("message", "Unknown error")
-            error_code = error.get("code", -1)
-            raise RuntimeError(f"RPC error: {error_msg} (code: {error_code})")
-
-        return response.get("result", {})
-
-    async def _handle_ping_event(self, data: dict):
-        """Handle system.ping event and reply with system.pong."""
-        import time
-        t1 = data.get("ping_time")
-        t2 = time.time()
-
-        await self._publish_event({
-            "event": "system.pong",
-            "data": {
-                "module_id": "evol",
-                "ping_time": t1,
-                "pong_time": t2,
-            },
-        })
-
-    async def _handle_event_notification(self, msg: dict):
-        params = msg.get("params", {})
-        event_type = params.get("event", "")
-        data = params.get("data", {})
-
-        # Handle system.ping event
-        if event_type == "system.ping":
-            await self._handle_ping_event(data)
-            return
-
-        print(f"[evol] Event received: {event_type}, data: {data}")
-
-        if event_type == "module.shutdown":
-            target = data.get("module_id", "")
-            reason = data.get("reason", "")
-            if target == "evol" or not target or reason == "launcher_lost":
-                await self._handle_shutdown()
-                return
-
-        # Forward module status events to management WebSocket clients
-        if event_type in (
-            "module.started", "module.stopped", "module.crashed",
-            "module.ready", "module.exiting",
-            "module.shutdown.ack", "module.shutdown.ready",
-        ):
-            await broadcast_event(event_type, data)
-            return
-
-        if event_type in SYSTEM_BROADCAST_EVENTS:
-            return
-
-        if os.environ.get("KITE_ENV") == "development":
-            print(f"[evol] Debug: Unhandled event: {event_type}")
-
-    async def _handle_rpc_request(self, ws, msg: dict):
-        rpc_id = msg.get("id", "")
-        method = msg.get("method", "")
-        params = msg.get("params", {})
-
-        if method.startswith("evol."):
-            method = method[5:]
-
-        handlers = {
-            "health": lambda p: self._rpc_health(),
-            "status": lambda p: self._rpc_status(),
-            "list_tokens": lambda p: self._rpc_list_tokens(),
-            "list_kite_tokens": lambda p: self._rpc_list_kite_tokens(),
-            "list_evol_tokens": lambda p: self._rpc_list_evol_tokens(),
-            "revoke_token": lambda p: self._rpc_revoke_token(p),
-            "subscribe_events": lambda p: self._rpc_subscribe_events(p),
-        }
-        handler = handlers.get(method)
-        if handler:
-            try:
-                result = await handler(params)
-                await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
-            except Exception as e:
-                await ws.send(json.dumps({
-                    "jsonrpc": "2.0", "id": rpc_id,
-                    "error": {"code": -32603, "message": str(e)},
-                }))
-        else:
-            await ws.send(json.dumps({
-                "jsonrpc": "2.0", "id": rpc_id,
-                "error": {"code": -32601, "message": f"Method not found: {method}"},
-            }))
-
-    async def _rpc_health(self) -> dict:
-        return {
-            "status": "healthy",
-            "details": {
-                "uptime_seconds": round(time.time() - self._start_time),
-            },
-        }
-
-    async def _rpc_status(self) -> dict:
-        return {
-            "module": "evol",
-            "status": "running",
-            "uptime_seconds": round(time.time() - self._start_time),
-        }
-
-    async def _rpc_list_tokens(self) -> dict:
-        """列出所有 Kite Token（从 AuthManager 读取）"""
-        latest_tokens = self.auth_manager._get_latest_tokens()
-        now = time.time()
-
-        tokens = []
-        for token, info in latest_tokens.items():
-            # 只返回有效且未过期的 token
-            if info.get("isValid", True) and now <= info.get("expiresAt", 0):
-                tokens.append({
-                    "token": token,
-                    "deviceId": info.get("deviceId", "unknown"),
-                    "deviceName": info.get("deviceName", "Unknown Device"),
-                    "phone": info.get("phone"),  # 添加绑定的手机号
-                    "createdAt": info.get("createdAt_human", ""),
-                    "lastUsedAt": info.get("lastUsedAt_human", ""),
-                    "expiresAt": info.get("expiresAt_human", ""),
-                })
-
-        return {"tokens": tokens}
-
-    async def _rpc_list_kite_tokens(self) -> dict:
-        """列出所有 Kite Token（前端配对令牌）"""
-        return await self._rpc_list_tokens()
-
-    async def _rpc_list_evol_tokens(self) -> dict:
-        """列出所有 Evol Token（Evol 云端令牌）"""
-        evol_records = self.auth_manager.list_all_evol_tokens()
-
-        if not evol_records:
-            return {"tokens": []}
-
-        tokens = []
-        for evol_record in evol_records:
-            # 提取用户信息
-            user_info = evol_record.get("userInfo", {})
-            account_info = evol_record.get("accountInfo", {})
-
-            tokens.append({
-                "token": evol_record.get("token", ""),
-                "phone": evol_record.get("phone", ""),
-                "nickName": user_info.get("nickName", ""),
-                "userName": user_info.get("userName", ""),
-                "credits": account_info.get("credits", 0),
-                "creditsLimit": account_info.get("creditsLimit", 0),
-                "vipType": account_info.get("vipType", 0),
-                "vipTypeName": account_info.get("vipTypeName", "Unknown"),
-                "vipExpireTime": account_info.get("vipExpireTime", ""),
-                "vipRemainingDays": account_info.get("vipRemainingDays", 0),
-                "obtainedAt": evol_record.get("obtainedAt_human", ""),
-                "lastUsedAt": evol_record.get("lastUsedAt_human", ""),
-                "expiresAt": evol_record.get("expiresAt_human", ""),
-            })
-
-        return {"tokens": tokens}
-
-    async def _rpc_revoke_token(self, params: dict) -> dict:
-        """吊销 Kite Token（使用 AuthManager）"""
-        token = params.get("token")
-        if not token:
-            raise ValueError("Missing token parameter")
-
-        # 验证 token 是否存在
-        latest_tokens = self.auth_manager._get_latest_tokens()
-        if token not in latest_tokens:
-            raise ValueError("Token not found")
-
-        # 吊销 token
-        self.auth_manager.revoke_kite_token(token)
-
-        return {"success": True, "message": "Token revoked successfully"}
-
-    async def _rpc_subscribe_events(self, params: dict) -> dict:
-        """动态订阅事件（通过 Kernel）"""
-        events = params.get("events", [])
-        if not events:
-            raise ValueError("Missing events parameter")
-
-        if not self._ws:
-            raise RuntimeError("Not connected to Kernel")
-
-        # 调用 Kernel 的 event.subscribe
-        rpc_id = f"rpc-{uuid.uuid4()}"
-        await self._ws.send(json.dumps({
-            "jsonrpc": "2.0",
-            "id": rpc_id,
-            "method": "event.subscribe",
-            "params": {"events": events}
-        }))
-
-        print(f"[evol] Subscribed to events: {events}")
-        return {"success": True, "events": events}
-
-    async def _handle_shutdown(self):
-        print("[evol] Received module.shutdown")
-        self._shutting_down = True
-
-        await self._publish_event({
-            "event": "module.shutdown.ack",
-            "data": {"module_id": "evol"},
-        })
-
-        await self._publish_event({
-            "event": "module.exiting",
-            "data": {
-                "module_id": "evol",
-                "type": "passive",
-                "reason": "shutdown_requested",
-                "restart": "auto",
-                "action": "none",
-                "timeout": 3.0,
-                "restart_delay": 0.0,
-            },
-        })
-
-        if self._test_task:
-            self._test_task.cancel()
-
-        # Close WebSocket connections
-        if hasattr(self.app.state, 'relay_service'):
-            await self.app.state.relay_service.close_all_sessions()
-
-        from extensions.services.evol.routes.routes_management_ws import close_all_clients
-        await close_all_clients()
-
-        await self._publish_event({
-            "event": "module.shutdown.ready",
-            "data": {"module_id": "evol"},
-        })
-
-        # 等待一小段时间确保事件发送完成
-        await asyncio.sleep(0.2)
-
-        # 关闭 Kernel WebSocket 连接
-        if self._ws:
-            try:
-                await self._ws.close(code=1000, reason="Graceful shutdown")
-                print("[evol] Kernel WebSocket closed")
-            except Exception as e:
-                print(f"[evol] Failed to close Kernel WebSocket: {e}")
-
-        # 触发 uvicorn 优雅关闭（让 uvicorn 自然退出，不要 sys.exit）
-        if self._uvicorn_server:
-            print("[evol] Triggering uvicorn graceful shutdown")
-            self._uvicorn_server.should_exit = True
-        else:
-            print("[evol] Warning: uvicorn_server not set")
-
-    async def _publish_event(self, event: dict):
-        if not self._ws:
-            return
-        try:
-            await self._rpc_call("event.publish", {
-                "event_id": str(uuid.uuid4()),
-                "event": event.get("event", ""),
-                "data": event.get("data", {}),
-            })
-        except Exception as e:
-            print(f"[evol] ERROR: Failed to publish event {event.get('event')}: {e}")
-
-    async def _test_event_loop(self):
-        while True:
-            await asyncio.sleep(10)
-            await self._publish_event({
-                "event": "evol.test",
-                "data": {
-                    "message": "test event from evol",
-                    "timestamp": datetime.now(timezone.utc).isoformat(),
-                },
-            })
-            print("[evol] test event published")
+"""
+Evol HTTP Server
+Evol account management with full Kite module management UI.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import random
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+import httpx
+import websockets
+from fastapi import FastAPI, WebSocket, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse, JSONResponse
+
+from extensions.services.evol.evol_api import EvolAPI
+
+# VIP 类型映射: vipType 数字 -> 名称
+VIP_TYPE_NAMES = {0: "Free", 1: "Plus", 2: "Pro", 3: "Max", 4: "Ultra"}
+from extensions.services.evol.auth_manager import AuthManager
+from extensions.services.evol.stats_manager import StatsManager
+from extensions.services.evol.routes.routes_rpc import router as rpc_router, set_evol_server
+from extensions.services.evol.routes.routes_test import router as test_router
+from extensions.services.evol.config_loader import load_business_configs
+from extensions.services.evol.pairing import PairingManager
+from extensions.services.evol.relay import KernelRelay
+
+
+def _fmt_elapsed(t0: float) -> str:
+    """Format elapsed time since t0."""
+    d = time.monotonic() - t0
+    if d < 1:
+        return f"{d * 1000:.0f}ms"
+    if d < 10:
+        return f"{d:.1f}s"
+    return f"{d:.0f}s"
+
+
+logger = logging.getLogger(__name__)
+
+# System broadcast events
+SYSTEM_BROADCAST_EVENTS = {
+    "module.ready", "module.registered", "module.started", "module.stopped",
+    "module.crashed", "module.exiting", "module.offline",
+    "module.shutdown.ack", "module.shutdown.ready",
+    "system.ready", "registry.updated",
+    "system.instance.started", "system.instance.stopped",
+}
+
+
+class EvolServer:
+    def __init__(self, module_name: str, token: str, kernel_port: int, host: str, port: int, boot_t0: float, max_connections: int = 1,
+                 gateway_url: str = "", kite_token: str = ""):
+        self.module_name = module_name
+        self.token = token
+        self.kernel_port = kernel_port
+        self.host = host
+        self.port = port
+        self.boot_t0 = boot_t0
+        self.max_connections = max_connections
+        self.gateway_url = gateway_url
+        self.kite_token = kite_token
+        self._ws_task: asyncio.Task | None = None
+        self._test_task: asyncio.Task | None = None
+        self._ws: object | None = None
+        self._shutting_down = False
+        self._exit_code = 0
+        self._auth_failed = False
+        self._uvicorn_server = None
+        self._start_time = time.time()
+        self._pending_rpc = {}
+        self._extra_ws: dict = {}           # slot → WebSocket
+        self._extra_ws_tasks: dict = {}     # slot → recv loop Task
+        self._has_registered = False
+
+        # 用户信息缓存（10秒有效期）
+        self._user_info_cache = {}  # {evol_token: {"data": ..., "timestamp": ...}}
+        self._cache_ttl = 10  # 缓存有效期（秒）
+
+        # Evol business managers
+        data_dir = os.environ.get("KITE_DATA", os.path.expanduser("~/.kite/data"))
+        evol_data_dir = os.path.join(data_dir, "evol")
+        os.makedirs(evol_data_dir, exist_ok=True)
+
+        self.evol_api = EvolAPI()
+        self.auth_manager = AuthManager(evol_data_dir)
+        self.stats_manager = StatsManager(evol_data_dir, self.evol_api, self.auth_manager)
+
+        # 页面注册表（page_id → 页面元数据）
+        self._page_registry: dict[str, dict] = {}
+        self._reserved_paths = {
+            "/", "/login", "/account", "/ai-service", "/credits",
+            "/team", "/commission", "/api", "/ws", "/health",
+            "/status", "/assets", "/module-ui"
+        }
+        self.relay = None  # relay 实例引用，在 _create_app 中初始化
+        self._ws_ready_event = None  # WS 连接就绪信号（在 event loop 中初始化）
+
+        self.app = self._create_app()
+
+    def _create_app(self) -> FastAPI:
+        app = FastAPI(title="Kite Evol Module", docs_url="/docs", redoc_url=None)
+        server = self
+
+        @app.on_event("startup")
+        async def _startup():
+            # Token already set in entry.py, no need to read from stdin
+            if not server.token:
+                print("[evol] ERROR: Missing token, cannot connect to Kernel")
+                return
+
+            server._ws_ready_event = asyncio.Event()
+
+            # Start Kernel WS connection (module.ready depends on this)
+            if server.kernel_port:
+                server._ws_task = asyncio.create_task(server._ws_loop())
+            server._test_task = asyncio.create_task(server._test_event_loop())
+
+            # Business initialization in background (does not block module.ready)
+            asyncio.create_task(_deferred_init())
+
+        async def _deferred_init():
+            """Business initialization that runs after WS connection starts."""
+            # 等待 WS 连接就绪（module.ready 已发布），最多等 30s
+            if server._ws_ready_event:
+                try:
+                    await asyncio.wait_for(server._ws_ready_event.wait(), timeout=30)
+                except asyncio.TimeoutError:
+                    print("[evol] WARNING: WS ready timeout, continuing deferred init")
+
+            # 检查本地是否有已登录的 evol_token，有则发布 evol.user_ready
+            await server._check_and_publish_user_ready()
+
+            await server.stats_manager.start()
+
+            # Load business configurations
+            module_dir = Path(__file__).parent
+            try:
+                business_configs = load_business_configs(str(module_dir))
+            except Exception as e:
+                logger.error(f"Failed to load business configs: {e}")
+                business_configs = {}
+
+            # Get relay service config
+            relay_business = business_configs.get('relay_service')
+            if relay_business:
+                try:
+                    relay_config = relay_business['config']
+
+                    # Initialize pairing manager
+                    auth_config = relay_config['auth']
+                    pairing_file = module_dir / auth_config['pairing_code_file']
+                    pairing_manager = PairingManager(
+                        pairing_file=str(pairing_file),
+                        code_length=auth_config['pairing_code_length'],
+                        token_expiry=auth_config['token_expiry']
+                    )
+                    app.state.pairing_manager = pairing_manager
+                    logger.info("Pairing manager initialized")
+
+                    # Initialize relay service
+                    relay_service = KernelRelay(
+                        kernel_host="127.0.0.1",
+                        kernel_port=server.kernel_port,
+                        kernel_token=server.token,
+                        base_module_id=relay_config['relay']['base_module_id'],
+                        reconnect_timeout=relay_config['relay']['reconnect_timeout'],
+                        permissions=relay_config['permissions'],
+                        pairing_manager=pairing_manager,
+                        evol_server=server,
+                        auth_manager=server.auth_manager  # 新增：传递 auth_manager
+                    )
+                    app.state.relay_service = relay_service
+                    server.relay = relay_service  # 保存引用供事件处理使用
+                    logger.info("Relay service initialized")
+                except KeyError as e:
+                    logger.error(f"Missing required config field for relay_service: {e}")
+                    logger.warning("Relay service disabled due to config error")
+                except Exception as e:
+                    logger.error(f"Failed to initialize relay_service: {e}", exc_info=True)
+                    logger.warning("Relay service disabled due to initialization error")
+            else:
+                logger.info("Relay service not configured (no 'relay_service' in businesses)")
+
+        @app.on_event("shutdown")
+        async def _shutdown():
+            await server.stats_manager.stop()
+            if server._ws_task:
+                server._ws_task.cancel()
+            if server._test_task:
+                server._test_task.cancel()
+            if server._ws:
+                await server._ws.close()
+            print("[evol] Shutdown complete")
+
+        # Health and status endpoints
+        @app.get("/health")
+        async def health():
+            return {
+                "status": "healthy",
+                "details": {
+                    "kernel_connected": server._ws is not None,
+                    "uptime_seconds": round(time.time() - server._start_time),
+                },
+            }
+
+        @app.get("/status")
+        async def status():
+            return {
+                "module": "evol",
+                "status": "running",
+                "kernel_connected": server._ws is not None,
+                "uptime_seconds": round(time.time() - server._start_time),
+            }
+
+        @app.get("/api/system_info")
+        async def system_info():
+            """获取系统版本和环境信息"""
+            # 从环境变量读取版本号和环境类型
+            version = os.environ.get("KITE_VERSION", "unknown")
+            env = os.environ.get("KITE_ENV", "development")
+
+            return {
+                "success": True,
+                "data": {
+                    "version": version,
+                    "environment": env
+                }
+            }
+
+        # Evol API routes
+        @app.post("/api/send_sms")
+        async def send_sms(request: Request):
+            data = await request.json()
+            phone = data.get("phone", "")
+            result = await server.evol_api.send_sms(phone)
+            return JSONResponse(result)
+
+        @app.post("/api/verify_sms")
+        async def verify_sms(request: Request):
+            data = await request.json()
+            phone = data.get("phone", "")
+            code = data.get("code", "")
+            device_info = data.get("deviceInfo", {})
+
+            result = await server.evol_api.verify_sms(phone, code)
+            if not result.get("success"):
+                return JSONResponse(result)
+
+            evol_data = result["data"]
+            evol_token = evol_data.get("token", "")
+            server.auth_manager.save_evol_token(phone, evol_token, evol_data)
+
+            # 生成 Kite Token
+            kite_token = server.auth_manager.generate_kite_token(device_info)
+
+            # 绑定 Kite Token 到手机号
+            server.auth_manager.bind_kite_token_to_phone(kite_token, phone)
+
+            # 登录成功，发布 evol.user_ready 通知其他模块
+            try:
+                await server._publish_user_ready(phone)
+            except Exception:
+                pass
+
+            return JSONResponse({
+                "success": True,
+                "kiteToken": kite_token,
+                "data": {
+                    "userInfo": evol_data.get("userInfo", {}),
+                    "apiKey": evol_data.get("apiKey", ""),
+                    "credits": evol_data.get("credits", 0)
+                }
+            })
+
+        @app.post("/api/get_user_info")
+        async def get_user_info(request: Request):
+            data = await request.json()
+            kite_token = data.get("kiteToken", "")
+
+            if not server.auth_manager.verify_kite_token(kite_token):
+                return JSONResponse({
+                    "success": False,
+                    "msg": "Kite Token 无效或已过期",
+                    "code": "INVALID_TOKEN"
+                })
+
+            # 根据 Kite Token 获取绑定的手机号
+            phone = server.auth_manager.get_phone_by_kite_token(kite_token)
+            if not phone:
+                return JSONResponse({
+                    "success": False,
+                    "msg": "未登录 Evol，请先登录",
+                    "code": "NOT_LOGGED_IN"
+                })
+
+            # 根据手机号获取 Evol Token
+            evol_record = server.auth_manager.get_evol_token(phone)
+            if not evol_record:
+                return JSONResponse({
+                    "success": False,
+                    "msg": "Evol Token 已过期，请重新登录",
+                    "code": "EVOL_TOKEN_EXPIRED"
+                })
+
+            # 更新 Evol Token 使用时间（超过 1 天才记录）
+            server.auth_manager.update_evol_token_usage(phone)
+
+            evol_token = evol_record["token"]
+
+            # 检查缓存
+            now = time.time()
+            if evol_token in server._user_info_cache:
+                cached = server._user_info_cache[evol_token]
+                if now - cached["timestamp"] < server._cache_ttl:
+                    logger.info(f"Using cached user info (age: {now - cached['timestamp']:.1f}s)")
+                    return JSONResponse(cached["data"])
+
+            # 缓存未命中或已过期，从云端获取
+            result = await server.evol_api.get_user_info(evol_token)
+            if not result.get("success"):
+                return JSONResponse(result)
+
+            # 手动触发账户信息采集
+            await server.stats_manager.collect_manual()
+
+            # 统一返回格式，与 verify_sms 保持一致
+            user_data = result["data"]
+            response_data = {
+                "success": True,
+                "data": user_data  # 返回完整数据
+            }
+
+            # 更新缓存
+            server._user_info_cache[evol_token] = {
+                "data": response_data,
+                "timestamp": now
+            }
+
+            return JSONResponse(response_data)
+
+        @app.post("/api/logout")
+        async def logout(request: Request):
+            data = await request.json()
+            kite_token = data.get("kiteToken", "")
+
+            if not server.auth_manager.verify_kite_token(kite_token):
+                return JSONResponse({"success": False, "msg": "Kite Token 无效"})
+
+            # 获取绑定的手机号
+            phone = server.auth_manager.get_phone_by_kite_token(kite_token)
+
+            # 吊销 Evol Token（如果已绑定手机号）
+            if phone:
+                server.auth_manager.revoke_evol_token(phone)
+
+            # 吊销 Kite Token（解除绑定）
+            server.auth_manager.revoke_kite_token(kite_token)
+
+            # 通知 Proxy 下线
+            try:
+                await server._publish_event({
+                    "event": "evol.user_logout",
+                    "data": {"phone": phone, "reason": "user_logout"},
+                })
+            except Exception as e:
+                print(f"[evol] 发布 user_logout 事件失败: {e}")
+
+            return JSONResponse({"success": True, "msg": "已退出登录"})
+
+        @app.post("/api/get_credits_stats")
+        async def get_credits_stats(request: Request):
+            data = await request.json()
+            kite_token = data.get("kiteToken", "")
+            period = data.get("period", "day")
+            date = data.get("date")
+
+            if not server.auth_manager.verify_kite_token(kite_token):
+                return JSONResponse({
+                    "success": False,
+                    "msg": "Kite Token 无效或已过期",
+                    "code": "INVALID_TOKEN"
+                })
+
+            result = server.stats_manager.get_stats(period, date)
+            return JSONResponse(result)
+
+        # Mount module management routes
+        app.include_router(rpc_router, prefix="/api")
+        app.include_router(test_router, prefix="/api")
+
+        # Relay WebSocket endpoint
+        @app.websocket("/ws/relay")
+        async def relay_endpoint(ws: WebSocket):
+            relay_service = getattr(app.state, 'relay_service', None)
+            if relay_service:
+                await relay_service.handle_client(ws)
+            else:
+                await ws.close(code=1011, reason="Relay service not initialized")
+
+        # Set evol server reference for RPC forwarding
+        set_evol_server(server)
+
+        # Serve frontend static files (Vue SPA)
+        static_dir = Path(__file__).parent / "static"
+        if static_dir.exists():
+            # Mount assets directory for Vite build output
+            assets_dir = static_dir / "assets"
+            if assets_dir.exists():
+                app.mount("/assets", StaticFiles(directory=str(assets_dir)), name="assets")
+
+            # Legacy routes for old test pages
+            @app.get("/pairing.html")
+            async def serve_pairing():
+                pairing_path = static_dir / "pairing.html"
+                if pairing_path.exists():
+                    return FileResponse(pairing_path)
+                return JSONResponse({"error": "Not found"}, status_code=404)
+
+            @app.get("/test_registry.html")
+            async def serve_test_registry():
+                test_path = static_dir / "test_registry.html"
+                if test_path.exists():
+                    return FileResponse(test_path)
+                return JSONResponse({"error": "Not found"}, status_code=404)
+
+            @app.get("/test_relay.html")
+            async def serve_test_relay():
+                test_path = static_dir / "test_relay.html"
+                if test_path.exists():
+                    return FileResponse(test_path)
+                return JSONResponse({"error": "Not found"}, status_code=404)
+
+            # SPA fallback - serve index.html for all unmatched routes
+            @app.get("/{full_path:path}")
+            async def serve_spa(full_path: str):
+                # Check if it's a static file request
+                file_path = static_dir / full_path
+                if file_path.exists() and file_path.is_file():
+                    return FileResponse(file_path)
+
+                # Otherwise serve index.html (SPA fallback)
+                index_path = static_dir / "index.html"
+                if index_path.exists():
+                    return FileResponse(index_path)
+                return JSONResponse({"error": "Not found"}, status_code=404)
+
+        return app
+
+    # ── Kernel WebSocket client ──
+
+    async def _ws_loop(self):
+        retry_delay = 0.5
+        max_delay = 30.0
+        attempt = 0
+        cooldown_attempts = 0
+
+        while not self._shutting_down:
+            try:
+                await self._ws_connect()
+                retry_delay = 0.5
+                attempt = 0
+                cooldown_attempts = 0
+            except asyncio.CancelledError:
+                print(f"WS loop cancelled")
+                return
+            except Exception as e:
+                if self._shutting_down:
+                    return
+
+                code = self._get_close_code(e)
+
+                # never: 永不重连
+                if code in (4001, 4003, 4004, 1008, 4010):
+                    print(f"\033[31m致命错误 (code {code})，退出\033[0m")
+                    self._exit_code = 1
+                    self._auth_failed = True
+                    self._shutting_down = True
+                    if self._uvicorn_server:
+                        self._uvicorn_server.should_exit = True
+                    return
+
+                # cooldown: 速率限制
+                if code == 4020:
+                    cooldown_attempts += 1
+                    if cooldown_attempts >= 5:
+                        print(f"\033[31m速率限制重试 5 次，退出\033[0m")
+                        self._exit_code = 1
+                        self._shutting_down = True
+                        if self._uvicorn_server:
+                            self._uvicorn_server.should_exit = True
+                        return
+                    print(f"\033[33m速率限制，10.0s 后重试 ({cooldown_attempts}/5)\033[0m")
+                    await asyncio.sleep(10.0)
+                    continue
+
+                # standard: 指数退避 + jitter
+                attempt += 1
+                jitter = retry_delay * 0.2 * random.random()
+                sleep_time = retry_delay + jitter
+                print(f"\033[31mKernel connection error: {e}, retrying in {sleep_time:.1f}s (attempt {attempt})\033[0m")
+
+            self._ws = None
+            if self._shutting_down:
+                return
+            await asyncio.sleep(sleep_time if 'sleep_time' in locals() else retry_delay)
+            retry_delay = min(retry_delay * 2, max_delay)
+
+    def _get_close_code(self, e: Exception) -> int:
+        """从 websockets 异常中提取关闭码"""
+        if hasattr(e, 'rcvd') and e.rcvd is not None:
+            return getattr(e.rcvd, 'code', 0)
+        return 0
+
+    async def _ws_receiver(self, ws):
+        """WebSocket 接收循环（后台任务）"""
+        try:
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+
+                try:
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+                    has_result_or_error = "result" in msg or "error" in msg
+
+                    # 检测 system.require_init 事件，触发注册流程
+                    if has_method and not has_id:
+                        params = msg.get("params", {})
+                        event = params.get("event", "")
+                        if event == "system.require_init":
+                            asyncio.create_task(self._do_init(ws))
+                            continue
+
+                    if has_method and not has_id:
+                        # 事件通知也需要异步处理，避免阻塞接收循环
+                        asyncio.create_task(self._handle_event_notification(msg))
+                    elif has_method and has_id:
+                        asyncio.create_task(self._handle_rpc_request(ws, msg))
+                    elif has_id and has_result_or_error:
+                        self._handle_rpc_response(msg)
+                except Exception as e:
+                    print(f"[evol] 消息处理异常（已忽略）: {e}")
+        except Exception as e:
+            print(f"[evol] Receive loop exited with exception: {e}")
+        finally:
+            print(f"[evol] Receive loop ended")
+
+    async def _do_init(self, ws):
+        """收到 system.require_init 后执行：订阅 + 注册 + module.ready"""
+        try:
+            reason = "startup" if not self._has_registered else "recovery"
+
+            # Subscribe to events
+            await self._rpc_call(ws, "event.subscribe", {
+                "events": [
+                    "module.started",
+                    "module.stopped",
+                    "module.crashed",
+                    "module.ready",
+                    "module.exiting",
+                    "module.shutdown",
+                    "module.shutdown.ack",
+                    "module.shutdown.ready",
+                    "module.offline",
+                    "ui.page.register",
+                    "ui.page.deregister",
+                ],
+            })
+
+            # Register to Kernel
+            await self._rpc_call(ws, "registry.register", {
+                "module_id": self.module_name,
+                "module_type": "service",
+                "base_url": f"http://127.0.0.1:{self.port}",
+                "health_path": "/health",
+                "tools": {
+                    "rpc": {
+                        "module": {
+                            "health": {"method": "health", "description": "健康检查"},
+                            "status": {"method": "status", "description": "状态查询"}
+                        },
+                        "evol": {
+                            "list_tokens": {"method": "list_tokens", "description": "列出所有令牌"},
+                            "list_kite_tokens": {"method": "list_kite_tokens", "description": "列出 Kite 令牌"},
+                            "list_evol_tokens": {"method": "list_evol_tokens", "description": "列出 Evol 令牌"},
+                            "revoke_token": {"method": "revoke_token", "description": "撤销 Kite 令牌"},
+                            "revoke_evol_token": {"method": "revoke_evol_token", "description": "撤销 Evol 令牌"},
+                            "get_user_aid": {"method": "get_user_aid", "description": "获取用户 AID 基本信息"},
+                            "get_user_aid_detail": {"method": "get_user_aid_detail", "description": "获取用户 AID 详细信息（含私钥/证书）"},
+                            "submit_user_aid": {"method": "submit_user_aid", "description": "提交用户 AID 信息到服务器"},
+                            "get_api_keys": {"method": "get_api_keys", "description": "获取用户的 API Key 列表"},
+                            "send_sms": {"method": "send_sms", "description": "发送短信验证码"},
+                            "verify_sms": {"method": "verify_sms", "description": "验证短信并登录"},
+                            "has_evol_token": {"method": "has_evol_token", "description": "检查是否有可用的 evol_token"}
+                        }
+                    }
+                },
+                "events_publish": {
+                    self.module_name: {
+                        "test": {"description": "Test event from evol module"},
+                        "started": {"description": "Evol UI started with access URL"},
+                        "user_ready": {"description": "用户登录状态可用（有 evol_token）"},
+                        "user_logout": {"description": "用户退出登录"},
+                    }
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.crashed",
+                    "module.ready",
+                    "module.exiting",
+                    "module.shutdown",
+                    "module.shutdown.ack",
+                    "module.shutdown.ready",
+                    "module.offline",
+                    "ui.page.register",
+                    "ui.page.deregister",
+                ],
+            })
+            print(f"[evol] Registered to Kernel")
+
+            # Send module.ready
+            if not self._shutting_down:
+                startup_time = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+                await self._publish_event(ws, "module.ready", {
+                    "module_id": self.module_name,
+                    "graceful_shutdown": True,
+                    "startup_time": startup_time,
+                    "reason": reason,
+                })
+                elapsed_str = _fmt_elapsed(self.boot_t0)
+                print(f"[evol] module.ready published (reason={reason}, {elapsed_str})")
+
+                # Publish evol.started event
+                display_host = "localhost" if self.host == "0.0.0.0" else self.host
+                access_url = f"http://{display_host}:{self.port}"
+                await self._publish_event(ws, "evol.started", {
+                    "module_id": self.module_name,
+                    "url": access_url,
+                    "host": self.host,
+                    "port": self.port,
+                })
+
+                # 通知 _deferred_init：WS 已就绪，可以发布业务事件
+                if self._ws_ready_event:
+                    self._ws_ready_event.set()
+                self._has_registered = True
+        except Exception as e:
+            print(f"[evol] _do_init failed: {e}")
+            self._has_registered = False
+
+    async def _ws_connect(self):
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?id={self.module_name}"
+        print(f"[evol] WS connecting to Kernel")
+        try:
+            async with websockets.connect(url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
+                # Send auth message first
+                auth_req = {
+                    "jsonrpc": "2.0",
+                    "id": "auth",
+                    "method": "auth",
+                    "params": {"token": self.token}
+                }
+                await ws.send(json.dumps(auth_req))
+
+                # Wait for auth response
+                auth_resp_raw = await asyncio.wait_for(ws.recv(), timeout=5)
+                auth_resp = json.loads(auth_resp_raw)
+                if "error" in auth_resp:
+                    raise Exception(f"Auth failed: {auth_resp['error']}")
+
+                self._ws = ws
+                elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+                elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
+                print(f"[evol] Connected to Kernel{elapsed_str}")
+
+                # 启动接收循环（后台任务）
+                receiver_task = asyncio.create_task(self._ws_receiver(ws))
+                print(f"[evol] Receiver task started")
+
+                try:
+                    # subscribe/register/module.ready 由 _do_init 在收到 system.require_init 后执行
+
+                    # 等待接收循环结束（连接断开）
+                    await receiver_task
+                except Exception as e:
+                    # 取消接收任务
+                    receiver_task.cancel()
+                    try:
+                        await receiver_task
+                    except asyncio.CancelledError:
+                        pass
+                    raise
+        except Exception as e:
+            print(f"[evol] WebSocket connection error: {e}")
+            raise
+        finally:
+            print(f"[evol] WebSocket connection closed")
+            self._ws = None
+            # 清理所有等待中的 RPC future
+            for fut in self._pending_rpc.values():
+                if not fut.done():
+                    fut.set_exception(ConnectionError("WebSocket disconnected"))
+            self._pending_rpc.clear()
+
+    async def _rpc_call(self, ws, method: str, params: dict = None,
+                        wait_response: bool = True, timeout: float = 3.0) -> dict:
+        """JSON-RPC 2.0 request。默认等待响应。"""
+        rpc_id = str(uuid.uuid4())
+        msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
+        if params:
+            msg["params"] = params
+        if not wait_response:
+            await ws.send(json.dumps(msg))
+            return {}
+        future = asyncio.get_event_loop().create_future()
+        self._pending_rpc[rpc_id] = future
+        await ws.send(json.dumps(msg))
+        try:
+            return await asyncio.wait_for(future, timeout=timeout)
+        except asyncio.TimeoutError:
+            self._pending_rpc.pop(rpc_id, None)
+            return {"error": {"code": -32000, "message": f"RPC timeout: {method} ({timeout}s)"}}
+
+    def _handle_rpc_response(self, msg: dict):
+        rpc_id = msg.get("id")
+        future = self._pending_rpc.pop(rpc_id, None)
+        if future and not future.done():
+            future.set_result(msg)
+
+    async def _handle_ping_event(self, data: dict):
+        """Handle system.ping event and reply with system.pong."""
+        import time
+        t1 = data.get("ping_time")
+        t2 = time.time()
+
+        await self._publish_event(self._ws, "system.pong", {
+            "module_id": self.module_name,
+            "ping_time": t1,
+            "pong_time": t2,
+        })
+
+    async def _handle_event_notification(self, msg: dict):
+        params = msg.get("params", {})
+        event_type = params.get("event", "")
+        data = params.get("data", {})
+        source = params.get("source", "")
+
+        # Handle system.ping event
+        if event_type == "system.ping":
+            await self._handle_ping_event(data)
+            return
+
+        # 弹性连接 offer/release
+        if event_type == "system.connection.offer":
+            asyncio.create_task(self._handle_connection_offer(data))
+            return
+        if event_type == "system.connection.release":
+            asyncio.create_task(self._handle_connection_release(data))
+            return
+
+        # Handle UI page registration
+        if event_type == "ui.page.register":
+            await self._handle_page_register(source, data)
+            return
+
+        if event_type == "ui.page.deregister":
+            await self._handle_page_deregister(data)
+            return
+
+        # Handle module offline - cleanup pages
+        if event_type == "module.offline":
+            module_id = data.get("module_id", "")
+            if module_id:
+                await self._cleanup_module_pages(module_id)
+            return
+
+        print(f"[evol] Event received: {event_type}, data: {data}")
+
+        if event_type == "module.shutdown":
+            target = data.get("module_id", "")
+            reason = data.get("reason", "")
+            if target == "evol" or not target or reason == "launcher_lost":
+                await self._handle_shutdown()
+                return
+
+        # Module status events are now handled by Kernel event system
+        # Clients subscribe via /ws/relay
+        if event_type in (
+            "module.started", "module.stopped", "module.crashed",
+            "module.ready", "module.exiting",
+            "module.shutdown.ack", "module.shutdown.ready",
+        ):
+            return
+
+        if event_type in SYSTEM_BROADCAST_EVENTS:
+            return
+
+        if os.environ.get("KITE_ENV") == "development":
+            print(f"[evol] Debug: Unhandled event: {event_type}")
+
+    async def _handle_rpc_request(self, ws, msg: dict):
+        rpc_id = msg.get("id", "")
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        if method.startswith("evol."):
+            method = method[5:]
+
+        handlers = {
+            "health": lambda p: self._rpc_health(),
+            "status": lambda p: self._rpc_status(),
+            "list_tokens": lambda p: self._rpc_list_tokens(),
+            "list_kite_tokens": lambda p: self._rpc_list_kite_tokens(),
+            "list_evol_tokens": lambda p: self._rpc_list_evol_tokens(),
+            "revoke_token": lambda p: self._rpc_revoke_token(p),
+            "revoke_evol_token": lambda p: self._rpc_revoke_evol_token(p),
+            "subscribe_events": lambda p: self._rpc_subscribe_events(p),
+            "get_user_info": lambda p: self._rpc_get_user_info(p),
+            "get_credits_stats": lambda p: self._rpc_get_credits_stats(p),
+            "logout": lambda p: self._rpc_logout(p),
+            "get_user_aid": lambda p: self._rpc_get_user_aid(p),
+            "get_user_aid_detail": lambda p: self._rpc_get_user_aid_detail(p),
+            "submit_user_aid": lambda p: self._rpc_submit_user_aid(p),
+            "get_api_keys": lambda p: self._rpc_get_api_keys(p),
+            "send_sms": lambda p: self._rpc_send_sms(p),
+            "verify_sms": lambda p: self._rpc_verify_sms(p),
+            "has_evol_token": lambda p: self._rpc_has_evol_token(),
+            "switch_team": lambda p: self._rpc_switch_team(p),
+            # 积分模块
+            "get_credits_change_records": lambda p: self._rpc_get_credits_change_records(p),
+            "get_credits_package_list": lambda p: self._rpc_get_credits_package_list(p),
+            "get_user_hourly_trend": lambda p: self._rpc_get_user_hourly_trend(p),
+            "get_user_daily_trend": lambda p: self._rpc_get_user_daily_trend(p),
+            "get_user_summary": lambda p: self._rpc_get_user_summary(p),
+            "get_credits_list": lambda p: self._rpc_get_credits_list(p),
+            # VIP 订阅模块
+            "get_vip_packages": lambda p: self._rpc_get_vip_packages(p),
+            "create_vip_order": lambda p: self._rpc_create_vip_order(p),
+            "get_order_list": lambda p: self._rpc_get_order_list(p),
+            "cancel_order": lambda p: self._rpc_cancel_order(p),
+            # 发票模块
+            "get_invoice_list": lambda p: self._rpc_get_invoice_list(p),
+            "apply_invoice": lambda p: self._rpc_apply_invoice(p),
+            # API Key 模块
+            "get_apikey_list": lambda p: self._rpc_get_apikey_list(p),
+            "create_apikey": lambda p: self._rpc_create_apikey(p),
+            "update_apikey": lambda p: self._rpc_update_apikey(p),
+            "delete_apikey": lambda p: self._rpc_delete_apikey(p),
+            # 团队模块
+            "get_team_members": lambda p: self._rpc_get_team_members(p),
+            "team.create": lambda p: self._rpc_team_create(p),
+            "team.get_detail": lambda p: self._rpc_team_get_detail(p),
+            "team.delete": lambda p: self._rpc_team_delete(p),
+            "team.quit": lambda p: self._rpc_team_quit(p),
+            "team.get_account": lambda p: self._rpc_team_get_account(p),
+            "team.search_user": lambda p: self._rpc_team_search_user(p),
+            "team.add_member": lambda p: self._rpc_team_add_member(p),
+            "team.batch_add_members": lambda p: self._rpc_team_batch_add_members(p),
+            "team.update_member": lambda p: self._rpc_team_update_member(p),
+            "team.remove_member": lambda p: self._rpc_team_remove_member(p),
+            "team.set_member_admin": lambda p: self._rpc_team_set_member_admin(p),
+            "team.remove_member_admin": lambda p: self._rpc_team_remove_member_admin(p),
+            "team.set_member_credits_limit": lambda p: self._rpc_team_set_member_credits_limit(p),
+            "team.batch_set_credits_limit": lambda p: self._rpc_team_batch_set_credits_limit(p),
+            "team.get_member_quota_info": lambda p: self._rpc_team_get_member_quota_info(p),
+            "team.reset_member_quota": lambda p: self._rpc_team_reset_member_quota(p),
+            "team.convert_member_credits": lambda p: self._rpc_team_convert_member_credits(p),
+            "team.update_share_creator_credits": lambda p: self._rpc_team_update_share_creator_credits(p),
+            "team.update_analyze_member_data": lambda p: self._rpc_team_update_analyze_member_data(p),
+            "team.get_credits_stats": lambda p: self._rpc_team_get_credits_stats(p),
+            "team.get_members_ranking": lambda p: self._rpc_team_get_members_ranking(p),
+            "team.get_trend": lambda p: self._rpc_team_get_trend(p),
+            "team.get_today_stats": lambda p: self._rpc_team_get_today_stats(p),
+            "team.get_today_members_stats": lambda p: self._rpc_team_get_today_members_stats(p),
+            "team.get_hourly_stats": lambda p: self._rpc_team_get_hourly_stats(p),
+            "team.get_weekly_stats": lambda p: self._rpc_team_get_weekly_stats(p),
+            "team.get_monthly_stats": lambda p: self._rpc_team_get_monthly_stats(p),
+            "team.get_credits_logs": lambda p: self._rpc_team_get_credits_logs(p),
+            "team.get_user_today_models": lambda p: self._rpc_team_get_user_today_models(p),
+            "team.statistics_history_30days": lambda p: self._rpc_team_statistics_history_30days(p),
+            "team.get_today_group_stats": lambda p: self._rpc_team_get_today_group_stats(p),
+            "team.get_history_group_stats": lambda p: self._rpc_team_get_history_group_stats(p),
+            "team.update_models": lambda p: self._rpc_team_update_models(p),
+            "team.get_member_model_settings": lambda p: self._rpc_team_get_member_model_settings(p),
+            "team.set_member_model_settings": lambda p: self._rpc_team_set_member_model_settings(p),
+            "team.create_group": lambda p: self._rpc_team_create_group(p),
+            "team.get_group_tree": lambda p: self._rpc_team_get_group_tree(p),
+            "team.get_group_detail": lambda p: self._rpc_team_get_group_detail(p),
+            "team.update_group": lambda p: self._rpc_team_update_group(p),
+            "team.delete_group": lambda p: self._rpc_team_delete_group(p),
+            "team.move_group": lambda p: self._rpc_team_move_group(p),
+            "team.add_members_to_group": lambda p: self._rpc_team_add_members_to_group(p),
+            "team.remove_members_from_group": lambda p: self._rpc_team_remove_members_from_group(p),
+            "team.get_group_members": lambda p: self._rpc_team_get_group_members(p),
+            "team.get_ungrouped_members": lambda p: self._rpc_team_get_ungrouped_members(p),
+            "team.get_my_group_scope": lambda p: self._rpc_team_get_my_group_scope(p),
+            "team.set_group_admin": lambda p: self._rpc_team_set_group_admin(p),
+            "team.remove_group_admin": lambda p: self._rpc_team_remove_group_admin(p),
+            "team.get_group_admins": lambda p: self._rpc_team_get_group_admins(p),
+            "team.get_bill_range": lambda p: self._rpc_team_get_bill_range(p),
+            "team.get_insight_reports": lambda p: self._rpc_team_get_insight_reports(p),
+            "team.get_insight_report_detail": lambda p: self._rpc_team_get_insight_report_detail(p),
+            "team.update_insight_config": lambda p: self._rpc_team_update_insight_config(p),
+            "team.generate_member_insight_report": lambda p: self._rpc_team_generate_member_insight_report(p),
+            "team.get_alert_config": lambda p: self._rpc_team_get_alert_config(p),
+            "team.update_alert_config": lambda p: self._rpc_team_update_alert_config(p),
+            "team.test_alert": lambda p: self._rpc_team_test_alert(p),
+            "team.reset_alert_status": lambda p: self._rpc_team_reset_alert_status(p),
+            "team.get_vip_packages": lambda p: self._rpc_team_get_vip_packages(p),
+            # 邀请分润模块
+            "commission.get_activities": lambda p: self._rpc_commission_get_activities(p),
+            "commission.join": lambda p: self._rpc_commission_join(p),
+            "commission.quit": lambda p: self._rpc_commission_quit(p),
+            "commission.get_participation": lambda p: self._rpc_commission_get_participation(p),
+            "commission.get_account": lambda p: self._rpc_commission_get_account(p),
+            "commission.get_summary": lambda p: self._rpc_commission_get_summary(p),
+            "commission.get_records": lambda p: self._rpc_commission_get_records(p),
+            "commission.transfer": lambda p: self._rpc_commission_transfer(p),
+            "commission.withdraw": lambda p: self._rpc_commission_withdraw(p),
+            "commission.get_withdrawals": lambda p: self._rpc_commission_get_withdrawals(p),
+        }
+        handler = handlers.get(method)
+        if handler:
+            try:
+                result = await handler(params)
+                await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
+            except Exception as e:
+                await ws.send(json.dumps({
+                    "jsonrpc": "2.0", "id": rpc_id,
+                    "error": {"code": -32603, "message": str(e)},
+                }))
+        else:
+            await ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": rpc_id,
+                "error": {"code": -32601, "message": f"Method not found: {method}"},
+            }))
+
+    async def _rpc_health(self) -> dict:
+        return {
+            "status": "healthy",
+            "details": {
+                "uptime_seconds": round(time.time() - self._start_time),
+            },
+        }
+
+    async def _rpc_status(self) -> dict:
+        return {
+            "module": "evol",
+            "status": "running",
+            "uptime_seconds": round(time.time() - self._start_time),
+        }
+
+    async def _rpc_list_tokens(self) -> dict:
+        """列出所有 Kite Token（从 AuthManager 读取）"""
+        latest_tokens = self.auth_manager._get_latest_tokens()
+        now = time.time()
+
+        tokens = []
+        for token, info in latest_tokens.items():
+            # 只返回有效且未过期的 token
+            if info.get("isValid", True) and now <= info.get("expiresAt", 0):
+                tokens.append({
+                    "token": token,
+                    "deviceId": info.get("deviceId", "unknown"),
+                    "deviceName": info.get("deviceName", "Unknown Device"),
+                    "phone": info.get("phone"),  # 添加绑定的手机号
+                    "createdAt": info.get("createdAt_human", ""),
+                    "lastUsedAt": info.get("lastUsedAt_human", ""),
+                    "expiresAt": info.get("expiresAt_human", ""),
+                })
+
+        return {"tokens": tokens}
+
+    async def _rpc_list_kite_tokens(self) -> dict:
+        """列出所有 Kite Token（前端配对令牌）"""
+        return await self._rpc_list_tokens()
+
+    async def _rpc_has_evol_token(self) -> dict:
+        """检查是否有可用的 evol_token（轻量级探测，供 proxy 主动查询）"""
+        evol_records = self.auth_manager.list_all_evol_tokens()
+        has_token = bool(evol_records)
+        phone = evol_records[0].get("phone", "") if evol_records else ""
+        masked_phone = f"{phone[:3]}****" if len(phone) >= 3 else phone
+        return {"has_token": has_token, "phone": masked_phone}
+
+    async def _rpc_list_evol_tokens(self) -> dict:
+        """列出所有 Evol Token（Evol 云端令牌）"""
+        evol_records = self.auth_manager.list_all_evol_tokens()
+
+        if not evol_records:
+            return {"tokens": []}
+
+        tokens = []
+        for evol_record in evol_records:
+            # 提取用户信息
+            user_info = evol_record.get("userInfo", {})
+            account_info = evol_record.get("accountInfo", {})
+
+            tokens.append({
+                "token": evol_record.get("token", ""),
+                "phone": evol_record.get("phone", ""),
+                "nickName": user_info.get("nickName", ""),
+                "userName": user_info.get("userName", ""),
+                "credits": account_info.get("credits", 0),
+                "creditsLimit": account_info.get("creditsLimit", 0),
+                "vipType": account_info.get("vipType", 0),
+                "vipTypeName": account_info.get("vipTypeName") or VIP_TYPE_NAMES.get(account_info.get("vipType", 0), "Unknown"),
+                "vipExpireTime": account_info.get("vipExpireTime", ""),
+                "vipRemainingDays": account_info.get("vipRemainingDays", 0),
+                "obtainedAt": evol_record.get("obtainedAt_human", ""),
+                "lastUsedAt": evol_record.get("lastUsedAt_human", ""),
+                "expiresAt": evol_record.get("expiresAt_human", ""),
+            })
+
+        return {"tokens": tokens}
+
+    async def _rpc_revoke_token(self, params: dict) -> dict:
+        """吊销 Kite Token（使用 AuthManager）"""
+        token = params.get("token")
+        if not token:
+            raise ValueError("Missing token parameter")
+
+        # 验证 token 是否存在
+        latest_tokens = self.auth_manager._get_latest_tokens()
+        if token not in latest_tokens:
+            raise ValueError("Token not found")
+
+        # 吊销 token
+        self.auth_manager.revoke_kite_token(token)
+
+        return {"success": True, "message": "Token revoked successfully"}
+
+    async def _rpc_revoke_evol_token(self, params: dict) -> dict:
+        """吊销 Evol Token（使用 AuthManager）"""
+        token = params.get("token")
+        if not token:
+            raise ValueError("Missing token parameter")
+
+        # 吊销 token
+        self.auth_manager.revoke_evol_token_by_token(token)
+
+        return {"success": True, "message": "Evol Token revoked successfully"}
+
+    async def _rpc_get_user_info(self, params: dict) -> dict:
+        """获取用户信息（RPC 版本）"""
+        kite_token = params.get("kiteToken", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {
+                "success": False,
+                "msg": "Kite Token 无效或已过期",
+                "code": "INVALID_TOKEN"
+            }
+
+        # 根据 Kite Token 获取绑定的手机号
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {
+                "success": False,
+                "msg": "未登录 Evol，请先登录",
+                "code": "NOT_LOGGED_IN"
+            }
+
+        # 根据手机号获取 Evol Token
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {
+                "success": False,
+                "msg": "Evol Token 已过期，请重新登录",
+                "code": "EVOL_TOKEN_EXPIRED"
+            }
+
+        # 更新 Evol Token 使用时间
+        self.auth_manager.update_evol_token_usage(phone)
+
+        evol_token = evol_record["token"]
+
+        # 检查缓存
+        now = time.time()
+        if evol_token in self._user_info_cache:
+            cached = self._user_info_cache[evol_token]
+            if now - cached["timestamp"] < self._cache_ttl:
+                logger.info(f"Using cached user info (age: {now - cached['timestamp']:.1f}s)")
+                return cached["data"]
+
+        # 缓存未命中或已过期，从云端获取
+        result = await self.evol_api.get_user_info(evol_token)
+        if not result.get("success"):
+            return result
+
+        # 手动触发账户信息采集
+        await self.stats_manager.collect_manual()
+
+        # 统一返回格式
+        user_data = result["data"]
+
+        # 补全 vipTypeName：如果远端 API 没有返回或返回了无效值，根据 vipType 映射
+        account_info = user_data.get("accountInfo", {})
+        if account_info:
+            vip_type_name = account_info.get("vipTypeName")
+            if not vip_type_name or vip_type_name == "Unknown":
+                vip_type = account_info.get("vipType", 0)
+                account_info["vipTypeName"] = VIP_TYPE_NAMES.get(vip_type, "Unknown")
+
+        response_data = {
+            "success": True,
+            "data": user_data
+        }
+
+        # 更新缓存
+        self._user_info_cache[evol_token] = {
+            "data": response_data,
+            "timestamp": now
+        }
+
+        return response_data
+
+    async def _rpc_get_credits_stats(self, params: dict) -> dict:
+        """获取积分统计（RPC 版本）"""
+        kite_token = params.get("kiteToken", "")
+        period = params.get("period", "day")
+        date = params.get("date")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {
+                "success": False,
+                "msg": "Kite Token 无效或已过期",
+                "code": "INVALID_TOKEN"
+            }
+
+        result = self.stats_manager.get_stats(period, date)
+        return result
+
+    async def _rpc_logout(self, params: dict) -> dict:
+        """退出登录（RPC 版本）"""
+        kite_token = params.get("kiteToken", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Kite Token 无效"}
+
+        # 获取绑定的手机号
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+
+        # 吊销 Evol Token（如果已绑定手机号）
+        if phone:
+            self.auth_manager.revoke_evol_token(phone)
+
+        # 吊销 Kite Token（解除绑定）
+        self.auth_manager.revoke_kite_token(kite_token)
+
+        # 通知 Proxy 下线
+        try:
+            await self._publish_event(self._ws, "evol.user_logout", {
+                "phone": phone, "reason": "user_logout",
+            })
+        except Exception as e:
+            print(f"[evol] 发布 user_logout 事件失败: {e}")
+
+        return {"success": True, "msg": "已退出登录"}
+
+    async def _rpc_get_user_aid(self, params: dict) -> dict:
+        """获取用户 AID 基本信息
+
+        Args:
+            params: {"evol_token": "..."}
+
+        Returns:
+            {"success": True, "data": {"aid": "...", ...}}
+        """
+        import aiohttp
+
+        evol_token = params.get("evol_token")
+        if not evol_token:
+            return {"success": False, "msg": "缺少 evol_token"}
+
+        try:
+            url = f"{self.evol_api.base_url}/system/user/aid"
+            headers = {
+                "Authorization": f"Bearer {evol_token}",
+                "Accept": "application/json",
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers, ssl=False, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                    if resp.status != 200:
+                        text = await resp.text()
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid: {text[:200]}"}
+                    try:
+                        data = await resp.json()
+                    except Exception:
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid: 响应非 JSON"}
+
+            if data.get("code") == 200:
+                return {"success": True, "data": data.get("data")}
+            else:
+                return {"success": False, "msg": data.get("msg", "未知错误")}
+
+        except Exception as e:
+            return {"success": False, "msg": f"请求失败: {e}"}
+
+    async def _rpc_get_user_aid_detail(self, params: dict) -> dict:
+        """获取用户 AID 详细信息（含私钥/证书）
+
+        Args:
+            params: {"evol_token": "...", "_caller_id": "proxy"}
+
+        Returns:
+            {"success": True, "data": {"aid": "...", "privateKey": "...", "pemStr": "...", ...}}
+        """
+        # 敏感接口：仅允许 proxy 模块调用
+        caller_id = params.get("_caller_id", "")
+        if caller_id != "proxy":
+            return {"success": False, "msg": f"权限不足: {caller_id or '未知模块'} 无权调用此方法"}
+
+        import aiohttp
+
+        evol_token = params.get("evol_token")
+        if not evol_token:
+            return {"success": False, "msg": "缺少 evol_token"}
+
+        try:
+            url = f"{self.evol_api.base_url}/system/user/aid/detail"
+            headers = {
+                "Authorization": f"Bearer {evol_token}",
+                "Accept": "application/json",
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers, ssl=False, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                    if resp.status != 200:
+                        text = await resp.text()
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid/detail: {text[:200]}"}
+                    try:
+                        data = await resp.json()
+                    except Exception:
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid/detail: 响应非 JSON"}
+
+            if data.get("code") == 200:
+                return {"success": True, "data": data.get("data")}
+            else:
+                return {"success": False, "msg": data.get("msg", "未知错误")}
+
+        except Exception as e:
+            return {"success": False, "msg": f"请求失败: {e}"}
+
+    async def _rpc_submit_user_aid(self, params: dict) -> dict:
+        """提交用户 AID 信息到服务器
+
+        Args:
+            params: {
+                "evol_token": "...",
+                "aid": "...",
+                "privateKey": "...",
+                "pemStr": "...",
+                "_caller_id": "proxy"
+            }
+
+        Returns:
+            {"success": True}
+        """
+        # 敏感接口：仅允许 proxy 模块调用
+        caller_id = params.get("_caller_id", "")
+        if caller_id != "proxy":
+            return {"success": False, "msg": f"权限不足: {caller_id or '未知模块'} 无权调用此方法"}
+
+        import aiohttp
+
+        evol_token = params.get("evol_token")
+        aid_data = {
+            "aid": params.get("aid"),
+            "privateKey": params.get("privateKey"),
+            "pemStr": params.get("pemStr"),
+        }
+
+        if not evol_token or not aid_data["aid"]:
+            return {"success": False, "msg": "缺少必要参数"}
+
+        try:
+            url = f"{self.evol_api.base_url}/system/user/aid"
+            headers = {
+                "Authorization": f"Bearer {evol_token}",
+                "Content-Type": "application/json",
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=aid_data, headers=headers, ssl=False, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                    if resp.status != 200:
+                        text = await resp.text()
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid (POST): {text[:200]}"}
+                    try:
+                        data = await resp.json()
+                    except Exception:
+                        return {"success": False, "msg": f"HTTP {resp.status} - /system/user/aid (POST): 响应非 JSON"}
+
+            if data.get("code") == 200:
+                return {"success": True}
+            else:
+                return {"success": False, "msg": data.get("msg", "未知错误")}
+
+        except Exception as e:
+            return {"success": False, "msg": f"请求失败: {e}"}
+
+    async def _rpc_get_api_keys(self, params: dict) -> dict:
+        """获取用户的 API Key 列表
+
+        Args:
+            params: {"kiteToken": "..."} 或 {"evol_token": "..."}
+
+        Returns:
+            {"success": True, "data": [...]}
+        """
+        import aiohttp
+
+        # 优先通过 kiteToken 查 evol_token
+        evol_token = params.get("evol_token")
+        kite_token = params.get("kiteToken", "")
+        if not evol_token and kite_token:
+            if not self.auth_manager.verify_kite_token(kite_token):
+                return {"success": False, "msg": "Token无效"}
+            phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+            if not phone:
+                return {"success": False, "msg": "未登录"}
+            evol_record = self.auth_manager.get_evol_token(phone)
+            if not evol_record:
+                return {"success": False, "msg": "Token已过期"}
+            evol_token = evol_record["token"]
+
+        if not evol_token:
+            return {"success": False, "msg": "缺少 evol_token 或 kiteToken"}
+
+        try:
+            url = f"{self.evol_api.base_url}/api/ai-key/list"
+            headers = {
+                "Authorization": f"Bearer {evol_token}",
+                "Accept": "application/json",
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers, ssl=False, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                    if resp.status != 200:
+                        text = await resp.text()
+                        return {"success": False, "msg": f"HTTP {resp.status} - /api/ai-key/list: {text[:200]}"}
+                    try:
+                        data = await resp.json()
+                    except Exception:
+                        return {"success": False, "msg": f"HTTP {resp.status} - /api/ai-key/list: 响应非 JSON"}
+
+            if data.get("code") == 200:
+                return {"success": True, "data": data.get("data", [])}
+            else:
+                return {"success": False, "msg": data.get("msg", "未知错误")}
+
+        except Exception as e:
+            return {"success": False, "msg": f"请求失败: {e}"}
+
+    async def _rpc_send_sms(self, params: dict) -> dict:
+        """发送短信验证码"""
+        phone = params.get("phone", "")
+        if not phone:
+            return {"success": False, "msg": "缺少手机号"}
+        result = await self.evol_api.send_sms(phone)
+        return result
+
+    async def _rpc_verify_sms(self, params: dict) -> dict:
+        """验证短信并登录"""
+        phone = params.get("phone", "")
+        code = params.get("code", "")
+        device_info = params.get("deviceInfo", {})
+
+        if not phone or not code:
+            return {"success": False, "msg": "缺少手机号或验证码"}
+
+        result = await self.evol_api.verify_sms(phone, code)
+        if not result.get("success"):
+            return result
+
+        evol_data = result["data"]
+        evol_token = evol_data.get("token", "")
+        self.auth_manager.save_evol_token(phone, evol_token, evol_data)
+
+        kite_token = self.auth_manager.generate_kite_token(device_info)
+        self.auth_manager.bind_kite_token_to_phone(kite_token, phone)
+
+        # 登录成功，发布 evol.user_ready 通知其他模块
+        try:
+            await self._publish_user_ready(phone)
+        except Exception:
+            pass
+
+        return {
+            "success": True,
+            "kiteToken": kite_token,
+            "data": {
+                "userInfo": evol_data.get("userInfo", {}),
+                "apiKey": evol_data.get("apiKey", ""),
+                "credits": evol_data.get("credits", 0)
+            }
+        }
+
+    async def _rpc_switch_team(self, params: dict) -> dict:
+        """切换团队"""
+        logger.info(f"[switch_team] Called with params: team_id={params.get('team_id')}")
+        kite_token = params.get("kiteToken", "")
+        team_id = params.get("team_id")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {
+                "status": "error",
+                "error": "Kite Token 无效或已过期",
+                "error_code": 401
+            }
+
+        # 根据 Kite Token 获取绑定的手机号
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {
+                "status": "error",
+                "error": "用户未登录，请先登录",
+                "error_code": 401
+            }
+
+        # 根据手机号获取 Evol Token
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {
+                "status": "error",
+                "error": "Token已失效，请重新登录",
+                "need_relogin": True,
+                "error_code": 401
+            }
+
+        evol_token = evol_record["token"]
+
+        # 调用 Evol API 切换团队
+        result = await self.evol_api.switch_team(evol_token, team_id)
+
+        # 清除用户信息缓存，强制下次重新获取
+        if evol_token in self._user_info_cache:
+            del self._user_info_cache[evol_token]
+
+        return result
+
+    # ==================== 积分模块 ====================
+
+    async def _rpc_get_credits_change_records(self, params: dict) -> dict:
+        """获取积分变动记录"""
+        kite_token = params.get("kiteToken", "")
+        page = params.get("page", 1)
+        page_size = params.get("pageSize", 20)
+        change_type = params.get("changeType")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_credits_change_records(evol_record["token"], page, page_size, change_type)
+
+    async def _rpc_get_credits_package_list(self, params: dict) -> dict:
+        """获取积分包列表"""
+        kite_token = params.get("kiteToken", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_credits_package_list(evol_record["token"])
+
+    async def _rpc_get_user_hourly_trend(self, params: dict) -> dict:
+        """获取个人24小时消耗趋势"""
+        kite_token = params.get("kiteToken", "")
+        date = params.get("date", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_user_hourly_trend(evol_record["token"], date)
+
+    async def _rpc_get_user_daily_trend(self, params: dict) -> dict:
+        """获取个人日消耗趋势"""
+        kite_token = params.get("kiteToken", "")
+        start_date = params.get("startDate", "")
+        end_date = params.get("endDate", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_user_daily_trend(evol_record["token"], start_date, end_date)
+
+    async def _rpc_get_user_summary(self, params: dict) -> dict:
+        """获取个人时间段汇总"""
+        kite_token = params.get("kiteToken", "")
+        start_date = params.get("startDate", "")
+        end_date = params.get("endDate", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_user_summary(evol_record["token"], start_date, end_date)
+
+    async def _rpc_get_credits_list(self, params: dict) -> dict:
+        """获取积分变动列表（分页）"""
+        kite_token = params.get("kiteToken", "")
+        page_num = params.get("pageNum", 1)
+        page_size = params.get("pageSize", 20)
+        start_time = params.get("startTime")
+        end_time = params.get("endTime")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_credits_list(evol_record["token"], page_num, page_size, start_time, end_time)
+
+    # ==================== VIP 订阅模块 ====================
+
+    async def _rpc_get_vip_packages(self, params: dict) -> dict:
+        """获取 VIP 套餐列表"""
+        kite_token = params.get("kiteToken", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_vip_packages(evol_record["token"])
+
+    async def _rpc_create_vip_order(self, params: dict) -> dict:
+        """创建 VIP 订单"""
+        kite_token = params.get("kiteToken", "")
+        package_id = params.get("packageId")
+        payment_method = params.get("paymentMethod", "alipay")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.create_vip_order(evol_record["token"], package_id, payment_method)
+
+    async def _rpc_get_order_list(self, params: dict) -> dict:
+        """获取订单列表"""
+        kite_token = params.get("kiteToken", "")
+        page = params.get("page", 1)
+        page_size = params.get("pageSize", 20)
+        order_type = params.get("orderType")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_order_list(evol_record["token"], page, page_size, order_type)
+
+    async def _rpc_cancel_order(self, params: dict) -> dict:
+        """取消订单"""
+        kite_token = params.get("kiteToken", "")
+        order_id = params.get("orderId")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.cancel_order(evol_record["token"], order_id)
+
+    # ==================== 发票模块 ====================
+
+    async def _rpc_get_invoice_list(self, params: dict) -> dict:
+        """获取发票列表"""
+        kite_token = params.get("kiteToken", "")
+        page = params.get("page", 1)
+        page_size = params.get("pageSize", 20)
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_invoice_list(evol_record["token"], page, page_size)
+
+    async def _rpc_apply_invoice(self, params: dict) -> dict:
+        """申请发票"""
+        kite_token = params.get("kiteToken", "")
+        order_id = params.get("orderId")
+        invoice_type = params.get("invoiceType")
+        title_type = params.get("titleType")
+        title = params.get("title")
+        tax_number = params.get("taxNumber", "")
+        email = params.get("email", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.apply_invoice(evol_record["token"], order_id, invoice_type, title_type, title, tax_number, email)
+
+    # ==================== API Key 模块 ====================
+
+    async def _rpc_get_apikey_list(self, params: dict) -> dict:
+        """获取 API Key 列表"""
+        kite_token = params.get("kiteToken", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_apikey_list(evol_record["token"])
+
+    async def _rpc_create_apikey(self, params: dict) -> dict:
+        """创建 API Key"""
+        kite_token = params.get("kiteToken", "")
+        name = params.get("name")
+        remark = params.get("remark", "")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.create_apikey(evol_record["token"], name, remark)
+
+    async def _rpc_update_apikey(self, params: dict) -> dict:
+        """更新 API Key"""
+        kite_token = params.get("kiteToken", "")
+        key_id = params.get("keyId")
+        name = params.get("name", "")
+        remark = params.get("remark", "")
+        status = params.get("status")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.update_apikey(evol_record["token"], key_id, name, remark, status)
+
+    async def _rpc_delete_apikey(self, params: dict) -> dict:
+        """删除 API Key"""
+        kite_token = params.get("kiteToken", "")
+        key_id = params.get("keyId")
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.delete_apikey(evol_record["token"], key_id)
+
+    # ==================== 团队模块 ====================
+
+    async def _rpc_get_team_members(self, params: dict) -> dict:
+        """获取团队成员列表"""
+        kite_token = params.get("kiteToken", "")
+        team_id = params.get("teamId")
+        page = params.get("page", 1)
+        page_size = params.get("pageSize", 20)
+
+        if not self.auth_manager.verify_kite_token(kite_token):
+            return {"success": False, "msg": "Token无效"}
+
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            return {"success": False, "msg": "未登录"}
+
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            return {"success": False, "msg": "Token已过期"}
+
+        return await self.evol_api.get_team_members(evol_record["token"], team_id, page, page_size)
+
+    async def _ensure_evol_token(self, params: dict) -> str:
+        """从 kiteToken 解析出 evol_token，失败则抛异常"""
+        kite_token = params.get("kiteToken", "")
+        if not self.auth_manager.verify_kite_token(kite_token):
+            raise ValueError("Token无效")
+        phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+        if not phone:
+            raise ValueError("未登录")
+        evol_record = self.auth_manager.get_evol_token(phone)
+        if not evol_record:
+            raise ValueError("Token已过期")
+        return evol_record["token"]
+
+    # ---- 团队基础 RPC ----
+
+    async def _rpc_team_create(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.create_team(token, params.get("name", ""))
+
+    async def _rpc_team_get_detail(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_team_detail(token, params["teamId"])
+
+    async def _rpc_team_delete(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.delete_team(token, params["teamId"])
+
+    async def _rpc_team_quit(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.quit_team(token, params["teamId"])
+
+    async def _rpc_team_get_account(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_team_account(token, params["teamId"])
+
+    async def _rpc_team_search_user(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.search_user(token, params.get("phonenumber", ""), params["teamId"])
+
+    # ---- 成员管理 RPC ----
+
+    async def _rpc_team_add_member(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.add_team_member(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_batch_add_members(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.batch_add_members(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_update_member(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_member(token, params["teamId"], params["memberId"], params.get("data", {}))
+
+    async def _rpc_team_remove_member(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.remove_member(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_set_member_admin(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.set_member_as_admin(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_remove_member_admin(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.remove_member_admin(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_set_member_credits_limit(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.set_member_credits_limit(token, params["teamId"], params["memberId"], params.get("data", {}))
+
+    async def _rpc_team_batch_set_credits_limit(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.batch_set_credits_limit(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_get_member_quota_info(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_member_quota_info(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_reset_member_quota(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.reset_member_quota(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_convert_member_credits(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.convert_member_credits(token, params["teamId"], params.get("data", {}))
+
+    # ---- 团队设置 RPC ----
+
+    async def _rpc_team_update_share_creator_credits(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_share_creator_credits(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_update_analyze_member_data(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_analyze_member_data(token, params["teamId"], params.get("data", {}))
+
+    # ---- 积分统计 RPC ----
+
+    async def _rpc_team_get_credits_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_credits_stats(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_members_ranking(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_members_ranking(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_trend(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_trend(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_today_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_today_team_stats(token, params["teamId"])
+
+    async def _rpc_team_get_today_members_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_today_members_stats(token, params["teamId"])
+
+    async def _rpc_team_get_hourly_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_hourly_stats(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_weekly_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_weekly_stats(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_monthly_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_monthly_stats(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_credits_logs(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_credits_logs(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_user_today_models(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_user_today_models(token, params["teamId"], params["userId"])
+
+    async def _rpc_team_statistics_history_30days(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.statistics_history_30days(token, params["teamId"], params.get("data"))
+
+    # ---- 分组统计 RPC ----
+
+    async def _rpc_team_get_today_group_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_today_group_stats(token, params["teamId"])
+
+    async def _rpc_team_get_history_group_stats(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_history_group_stats(token, params["teamId"], **kw)
+
+    # ---- 模型管理 RPC ----
+
+    async def _rpc_team_update_models(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_team_models(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_get_member_model_settings(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_member_model_settings(token, params["teamId"], params["memberId"])
+
+    async def _rpc_team_set_member_model_settings(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.set_member_model_settings(token, params["teamId"], params["memberId"], params.get("data", {}))
+
+    # ---- 分组管理 RPC ----
+
+    async def _rpc_team_create_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.create_group(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_get_group_tree(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_group_tree(token, params["teamId"])
+
+    async def _rpc_team_get_group_detail(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_group_detail(token, params["teamId"], params["groupId"])
+
+    async def _rpc_team_update_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_group(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_delete_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.delete_group(token, params["teamId"], params["groupId"])
+
+    async def _rpc_team_move_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.move_group(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_add_members_to_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.add_members_to_group(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_remove_members_from_group(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.remove_members_from_group(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_get_group_members(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId", "groupId") and v is not None}
+        return await self.evol_api.get_group_members(token, params["teamId"], params["groupId"], **kw)
+
+    async def _rpc_team_get_ungrouped_members(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_ungrouped_members(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_my_group_scope(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_my_group_scope(token, params["teamId"])
+
+    # ---- 分组管理员 RPC ----
+
+    async def _rpc_team_set_group_admin(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.set_group_admin(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_remove_group_admin(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.remove_group_admin(token, params["teamId"], params["groupId"], params.get("data", {}))
+
+    async def _rpc_team_get_group_admins(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_group_admins(token, params["teamId"], params["groupId"])
+
+    # ---- 账单 RPC ----
+
+    async def _rpc_team_get_bill_range(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_team_bill_range(token, params["teamId"], **kw)
+
+    # ---- 洞察报告 RPC ----
+
+    async def _rpc_team_get_insight_reports(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        kw = {k: v for k, v in params.items() if k not in ("kiteToken", "teamId") and v is not None}
+        return await self.evol_api.get_insight_reports(token, params["teamId"], **kw)
+
+    async def _rpc_team_get_insight_report_detail(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_insight_report_detail(token, params["teamId"], params["reportId"])
+
+    async def _rpc_team_update_insight_config(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_insight_config(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_generate_member_insight_report(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.generate_member_insight_report(token, params["teamId"], params["userId"], params.get("date"))
+
+    # ---- 预警 RPC ----
+
+    async def _rpc_team_get_alert_config(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_alert_config(token, params["teamId"])
+
+    async def _rpc_team_update_alert_config(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.update_alert_config(token, params["teamId"], params.get("data", {}))
+
+    async def _rpc_team_test_alert(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.test_alert(token, params["teamId"])
+
+    async def _rpc_team_reset_alert_status(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.reset_alert_status(token, params["teamId"])
+
+    # ---- VIP 套餐（团队版） ----
+
+    async def _rpc_team_get_vip_packages(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        url = f"{self.evol_api.base_url}/api/vip/packages?targetType=1"
+        headers = {"Authorization": f"Bearer {token}"}
+        try:
+            async with httpx.AsyncClient(timeout=self.evol_api.timeout) as client:
+                response = await client.get(url, headers=headers)
+                result = response.json()
+                return {"success": result.get("code") == 200, "data": result.get("data"), "msg": result.get("msg")}
+        except Exception as e:
+            return {"success": False, "msg": f"网络错误: {str(e)}"}
+
+    # ==================== 邀请分润 RPC ====================
+
+    async def _rpc_commission_get_activities(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_activities(token)
+
+    async def _rpc_commission_join(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.join_commission_activity(
+            token, params.get("activityId"), params.get("inviteCode"))
+
+    async def _rpc_commission_quit(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.quit_commission_activity(token)
+
+    async def _rpc_commission_get_participation(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_participation(token)
+
+    async def _rpc_commission_get_account(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_account(token)
+
+    async def _rpc_commission_get_summary(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_summary(token)
+
+    async def _rpc_commission_get_records(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_records(
+            token, params.get("startDate"), params.get("endDate"))
+
+    async def _rpc_commission_transfer(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.transfer_commission(token, params.get("creditsAmount", 0))
+
+    async def _rpc_commission_withdraw(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.withdraw_commission(token, params.get("creditsAmount", 0))
+
+    async def _rpc_commission_get_withdrawals(self, params: dict) -> dict:
+        token = await self._ensure_evol_token(params)
+        return await self.evol_api.get_commission_withdrawals(
+            token, params.get("startDate"), params.get("endDate"))
+
+    async def _rpc_subscribe_events(self, params: dict) -> dict:
+        """动态订阅事件（通过 Kernel）"""
+        events = params.get("events", [])
+        if not events:
+            raise ValueError("Missing events parameter")
+
+        if not self._ws:
+            raise RuntimeError("Not connected to Kernel")
+
+        # 调用 Kernel 的 event.subscribe（fire-and-forget）
+        await self._rpc_call(self._ws, "event.subscribe", {"events": events},
+                             wait_response=False)
+
+        print(f"[evol] Subscribed to events: {events}")
+        return {"success": True, "events": events}
+
+    async def _handle_connection_offer(self, data):
+        """处理 Kernel 下发的 slot token，建立附加连接。"""
+        slots = data.get("slots", {})
+        for slot_str, info in slots.items():
+            slot = int(slot_str)
+            token = info.get("token", "")
+            if not token or slot in self._extra_ws:
+                continue
+            asyncio.create_task(self._connect_slot(slot, token))
+
+    async def _connect_slot(self, slot, token):
+        """建立单个 slot 附加连接。"""
+        ws_url = f"ws://127.0.0.1:{self.kernel_port}/ws"
+        try:
+            ws = await websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=5)
+            auth_req = {"jsonrpc": "2.0", "id": f"auth-slot-{slot}", "method": "auth", "params": {"token": token}}
+            await ws.send(json.dumps(auth_req))
+            resp = json.loads(await asyncio.wait_for(ws.recv(), timeout=5))
+            if "error" in resp:
+                await ws.close()
+                return
+            self._extra_ws[slot] = ws
+            self._extra_ws_tasks[slot] = asyncio.create_task(self._slot_recv_loop(slot, ws))
+            print(f"[evol] Slot {slot} connected")
+        except Exception as e:
+            print(f"[evol] Slot {slot} connect failed: {e}")
+
+    async def _slot_recv_loop(self, slot, ws):
+        """附加 slot 接收循环：与主连接平等处理所有消息。"""
+        try:
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except (json.JSONDecodeError, TypeError):
+                    continue
+
+                try:
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+                    has_result_or_error = "result" in msg or "error" in msg
+
+                    if has_method and not has_id:
+                        asyncio.create_task(self._handle_event_notification(msg))
+                    elif has_method and has_id:
+                        asyncio.create_task(self._handle_rpc_request(ws, msg))
+                    elif has_id and has_result_or_error:
+                        self._handle_rpc_response(msg)
+                except Exception as e:
+                    print(f"[evol] Slot {slot} 消息处理异常（已忽略）: {e}")
+        except Exception as e:
+            print(f"[evol] Slot {slot} recv loop exited: {e}")
+        finally:
+            self._extra_ws.pop(slot, None)
+            self._extra_ws_tasks.pop(slot, None)
+
+    async def _handle_connection_release(self, data):
+        """Kernel 请求释放 slot，优雅关闭。"""
+        for slot in data.get("slots", []):
+            ws = self._extra_ws.pop(slot, None)
+            task = self._extra_ws_tasks.pop(slot, None)
+            if ws:
+                try:
+                    await ws.close(code=1000, reason="release")
+                except Exception:
+                    pass
+            if task:
+                task.cancel()
+
+    async def _handle_shutdown(self):
+        print("[evol] Received module.shutdown")
+        self._shutting_down = True
+
+        # 使用短超时发送 shutdown 事件，避免阻塞
+        try:
+            await self._publish_event(self._ws, "module.shutdown.ack", {
+                "module_id": self.module_name,
+            })
+        except Exception as e:
+            print(f"[evol] Failed to send shutdown.ack: {e}")
+
+        try:
+            await self._publish_event(self._ws, "module.exiting", {
+                "module_id": self.module_name,
+                "type": "passive",
+                "reason": "shutdown_requested",
+                "restart": "auto",
+                "action": "none",
+                "timeout": 3.0,
+                "restart_delay": 0.0,
+            })
+        except Exception as e:
+            print(f"[evol] Failed to send module.exiting: {e}")
+
+        # Send shutdown.ready（必须在关闭连接之前发送）
+        try:
+            await self._publish_event(self._ws, "module.shutdown.ready", {
+                "module_id": self.module_name,
+            })
+        except Exception as e:
+            print(f"[evol] Failed to send shutdown.ready: {e}")
+
+        # 等待 Kernel 处理 shutdown.ready
+        await asyncio.sleep(0.01)
+
+        if self._test_task:
+            self._test_task.cancel()
+
+        # Close WebSocket connections
+        if hasattr(self.app.state, 'relay_service'):
+            try:
+                await asyncio.wait_for(
+                    self.app.state.relay_service.close_all_sessions(),
+                    timeout=1.0
+                )
+            except asyncio.TimeoutError:
+                print("[evol] Relay service close timeout")
+            except Exception as e:
+                print(f"[evol] Failed to close relay sessions: {e}")
+
+        # 关闭所有附加连接
+        for _s, _w in list(self._extra_ws.items()):
+            try:
+                await _w.close(code=1000, reason="shutdown")
+            except Exception:
+                pass
+        for _t in self._extra_ws_tasks.values():
+            _t.cancel()
+        self._extra_ws.clear()
+        self._extra_ws_tasks.clear()
+
+        # 关闭 Kernel WebSocket 连接
+        if self._ws:
+            try:
+                await self._ws.close(code=1000, reason="Graceful shutdown")
+                print("[evol] Kernel WebSocket closed")
+            except Exception as e:
+                print(f"[evol] Failed to close Kernel WebSocket: {e}")
+
+        # 触发 uvicorn 优雅关闭（让 uvicorn 自然退出，不要 sys.exit）
+        if self._uvicorn_server:
+            print("[evol] Triggering uvicorn graceful shutdown")
+            self._uvicorn_server.should_exit = True
+        else:
+            print("[evol] Warning: uvicorn_server not set")
+
+    async def _publish_event(self, ws, event: str, data: dict = None):
+        """Publish event via event.publish RPC (fire-and-forget)."""
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": event,
+            "data": data or {},
+        }, wait_response=False)
+
+    async def _check_and_publish_user_ready(self):
+        """检查本地是否有已登录的 evol_token，有则发布 evol.user_ready"""
+        try:
+            evol_records = self.auth_manager.list_all_evol_tokens()
+            if evol_records:
+                phone = evol_records[0].get("phone", "")
+                print(f"[evol] 检测到本地已登录 token (phone: {phone[:3]}****)，发布 user_ready")
+                await self._publish_user_ready(phone)
+        except Exception as e:
+            print(f"[evol] 检查本地 token 失败: {e}")
+
+    async def _publish_user_ready(self, phone: str = ""):
+        """发布 evol.user_ready 事件"""
+        masked_phone = f"{phone[:3]}****" if len(phone) >= 3 else phone
+        await self._publish_event(self._ws, "evol.user_ready", {
+            "module_id": self.module_name,
+            "has_token": True,
+            "phone": masked_phone,
+        })
+
+    async def _test_event_loop(self):
+        try:
+            while True:
+                await asyncio.sleep(10)
+                await self._publish_event(self._ws, "evol.test", {
+                    "message": "test event from evol",
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                })
+        except Exception:
+            pass
+
+    async def _handle_page_register(self, source: str, data: dict):
+        """处理页面注册事件"""
+        page_id = data.get("page_id")
+        path = data.get("path")
+        page_type = data.get("type")
+
+        if not page_id or not path or not page_type:
+            print(f"[evol] Invalid page registration from {source}: missing required fields")
+            return
+
+        # 检查路径冲突
+        if path in self._reserved_paths:
+            print(f"[evol] Page registration rejected: path {path} is reserved")
+            return
+
+        # 检查是否与已注册页面冲突
+        for pid, page in self._page_registry.items():
+            if pid != page_id and page.get("path") == path:
+                print(f"[evol] Page registration rejected: path {path} already used by {pid}")
+                return
+
+        # 存入注册表
+        page_entry = {**data, "module_id": source}
+        self._page_registry[page_id] = page_entry
+        print(f"[evol] Page registered: {page_id} from {source}")
+
+        # 动态挂载静态文件（hosted 类型）
+        if page_type == "hosted":
+            await self._mount_module_ui(source)
+
+        # 推送给前端（通过 relay）
+        if hasattr(self, 'relay') and self.relay:
+            await self.relay.broadcast_to_clients({
+                "jsonrpc": "2.0",
+                "method": "event",
+                "params": {
+                    "event": "ui.page.register",
+                    "source": source,
+                    "data": page_entry
+                }
+            })
+
+    async def _handle_page_deregister(self, data: dict):
+        """处理页面反注册事件"""
+        page_id = data.get("page_id")
+        if not page_id:
+            return
+
+        page = self._page_registry.pop(page_id, None)
+        if page:
+            print(f"[evol] Page deregistered: {page_id}")
+            # 推送给前端
+            if hasattr(self, 'relay') and self.relay:
+                await self.relay.broadcast_to_clients({
+                    "jsonrpc": "2.0",
+                    "method": "event",
+                    "params": {
+                        "event": "ui.page.deregister",
+                        "data": {"page_id": page_id}
+                    }
+                })
+
+    async def _cleanup_module_pages(self, module_id: str):
+        """清理模块的所有页面"""
+        pages_to_remove = [
+            page_id for page_id, page in self._page_registry.items()
+            if page.get("module_id") == module_id
+        ]
+
+        for page_id in pages_to_remove:
+            await self._handle_page_deregister({"page_id": page_id})
+
+    async def _mount_module_ui(self, module_name: str):
+        """动态挂载模块的 UI 静态文件"""
+        # 查找模块的 ui 目录
+        possible_paths = [
+            Path(f"extensions/services/{module_name}/ui"),
+            Path(os.environ.get("KITE_INSTANCE_DIR", "")) / module_name / "ui"
+        ]
+
+        ui_dir = None
+        for p in possible_paths:
+            if p.exists() and p.is_dir():
+                ui_dir = p
+                break
+
+        if not ui_dir:
+            print(f"[evol] Warning: UI directory not found for module {module_name}")
+            return
+
+        # 动态挂载
+        mount_path = f"/module-ui/{module_name}"
+        try:
+            self.app.mount(
+                mount_path,
+                StaticFiles(directory=str(ui_dir), html=True),
+                name=f"module-ui-{module_name}"
+            )
+            print(f"[evol] Mounted UI for {module_name} at {mount_path}")
+        except Exception as e:
+            print(f"[evol] Failed to mount UI for {module_name}: {e}")