@agentunion/kite 1.3.2 → 1.5.0

package/extensions/services/evol/server.py

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