@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/kite_console/server.py

@@ -0,0 +1,1742 @@
+"""
+Evol HTTP Server
+Evol account management with full Kite module management UI.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+import random
+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.kite_console.evol_api import EvolAPI
+from extensions.services.kite_console.auth_manager import AuthManager
+from extensions.services.kite_console.stats_manager import StatsManager
+from extensions.services.kite_console.routes.routes_rpc import router as rpc_router, set_evol_server
+from extensions.services.kite_console.routes.routes_test import router as test_router
+from extensions.services.kite_console.routes.routes_llm import router as llm_router
+from extensions.services.kite_console.routes.routes_proxy import router as proxy_router, set_proxy_server
+from extensions.services.kite_console.config_loader import load_business_configs
+from extensions.services.kite_console.pairing import PairingManager
+from extensions.services.kite_console.relay import KernelRelay
+from extensions.services.kite_console.oauth_manager import OAuthManager
+
+
+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
+        # Kernel 重连状态（供 relay 报告给前端）
+        self._kernel_reconnect_info = {
+            "state": "connected",  # connected / reconnecting / fatal / exiting
+            "attempt": 0,
+            "max_attempts": 10,
+            "next_retry_ms": 0,
+        }
+
+        # 用户信息缓存（10秒有效期）
+        self._user_info_cache = {}  # {evol_token: {"data": ..., "timestamp": ...}}
+        self._cache_ttl = 30  # 缓存有效期（秒）
+
+        # Business data directory
+        data_dir = os.environ.get("KITE_DATA", os.path.expanduser("~/.kite/data"))
+        console_data_dir = os.path.join(data_dir, "kite_console")
+        os.makedirs(console_data_dir, exist_ok=True)
+
+        self.evol_api = EvolAPI()
+        self.auth_manager = AuthManager(console_data_dir)
+        self.stats_manager = StatsManager(console_data_dir, self.evol_api, self.auth_manager)
+
+        # OAuth manager（从 config.json5 加载配置）
+        self.oauth_manager = self._init_oauth_manager()
+
+        self.app = self._create_app()
+
+    def _init_oauth_manager(self) -> OAuthManager:
+        """从 config.json5 加载 OAuth 配置并初始化 OAuthManager"""
+        import json5
+        config_path = Path(__file__).parent / "config.json5"
+        oauth_cfg = {}
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    cfg = json5.load(f)
+                oauth_cfg = cfg.get("oauth", {})
+            except Exception as e:
+                logger.warning(f"Failed to load OAuth config: {e}")
+
+        return OAuthManager(
+            state_mode=oauth_cfg.get("state_mode", "memory"),
+            state_ttl=oauth_cfg.get("state_ttl", 60),
+            jwt_secret=oauth_cfg.get("jwt_secret", ""),
+        )
+
+    def _create_app(self) -> FastAPI:
+        app = FastAPI(title="Kite Console", 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(f"\033[31mERROR: Missing token, cannot connect to Kernel\033[0m")
+                return
+
+            # 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."""
+            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,
+                        oauth_manager=server.oauth_manager,
+                    )
+                    app.state.relay_service = relay_service
+                    server.relay = relay_service  # server.py 中用于通知 relay kernel 状态变化
+                    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(f"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": server.module_name,
+                "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)
+
+            return JSONResponse({
+                "success": True,
+                "kiteToken": kite_token,
+                "data": {
+                    "userInfo": evol_data.get("userInfo", {}),
+                    "apiKey": evol_data.get("apiKey", ""),
+                    "credits": evol_data.get("credits", 0)
+                }
+            })
+
+        # Mount module management routes
+        app.include_router(rpc_router, prefix="/api")
+        app.include_router(test_router, prefix="/api")
+        app.include_router(llm_router, prefix="/api")
+        app.include_router(proxy_router, prefix="/api")
+
+        # ── OAuth routes ──
+
+        @app.get("/auth/oauth/{provider}/authorize")
+        async def oauth_authorize(provider: str, redirect_uri: str = ""):
+            """发起 OAuth 授权，返回重定向 URL"""
+            import json5
+            config_path = Path(__file__).parent / "config.json5"
+            oauth_cfg = {}
+            if config_path.exists():
+                try:
+                    with open(config_path, "r", encoding="utf-8") as f:
+                        cfg = json5.load(f)
+                    oauth_cfg = cfg.get("oauth", {})
+                except Exception:
+                    pass
+
+            providers = oauth_cfg.get("providers", {})
+            provider_cfg = providers.get(provider)
+            if not provider_cfg or not provider_cfg.get("client_id"):
+                return JSONResponse(
+                    {"error": f"OAuth provider '{provider}' not configured"},
+                    status_code=400
+                )
+
+            # 生成 state（CSRF 防护）
+            state = server.oauth_manager.generate_state(provider, redirect_uri)
+
+            # 构建授权 URL
+            client_id = provider_cfg["client_id"]
+            cb_uri = provider_cfg.get("redirect_uri", "")
+
+            if provider == "github":
+                auth_url = (
+                    f"https://github.com/login/oauth/authorize"
+                    f"?client_id={client_id}&state={state}"
+                    f"&redirect_uri={cb_uri}&scope=read:user,user:email"
+                )
+            elif provider == "google":
+                auth_url = (
+                    f"https://accounts.google.com/o/oauth2/v2/auth"
+                    f"?client_id={client_id}&state={state}"
+                    f"&redirect_uri={cb_uri}&scope=openid+email+profile"
+                    f"&response_type=code&access_type=offline"
+                )
+            else:
+                return JSONResponse(
+                    {"error": f"Unsupported OAuth provider: {provider}"},
+                    status_code=400
+                )
+
+            return JSONResponse({"authorize_url": auth_url, "state": state})
+
+        @app.get("/auth/oauth/callback")
+        async def oauth_callback(request: Request):
+            """OAuth 回调，用 code 换 token，生成 auth_ticket"""
+            import httpx
+
+            code = request.query_params.get("code")
+            state = request.query_params.get("state")
+
+            if not code or not state:
+                return JSONResponse({"error": "Missing code or state"}, status_code=400)
+
+            # 验证 state
+            state_info = server.oauth_manager.verify_state(state)
+            if not state_info:
+                return JSONResponse({"error": "Invalid or expired state"}, status_code=400)
+
+            provider = state_info["provider"]
+
+            # 加载 provider 配置
+            import json5
+            config_path = Path(__file__).parent / "config.json5"
+            oauth_cfg = {}
+            if config_path.exists():
+                try:
+                    with open(config_path, "r", encoding="utf-8") as f:
+                        cfg = json5.load(f)
+                    oauth_cfg = cfg.get("oauth", {})
+                except Exception:
+                    pass
+
+            provider_cfg = oauth_cfg.get("providers", {}).get(provider, {})
+            client_id = provider_cfg.get("client_id", "")
+            client_secret = provider_cfg.get("client_secret", "")
+            cb_uri = provider_cfg.get("redirect_uri", "")
+
+            if not client_id or not client_secret:
+                return JSONResponse({"error": "OAuth provider not properly configured"}, status_code=500)
+
+            try:
+                async with httpx.AsyncClient(timeout=10) as client:
+                    # 用 code 换 access_token
+                    if provider == "github":
+                        token_resp = await client.post(
+                            "https://github.com/login/oauth/access_token",
+                            json={"client_id": client_id, "client_secret": client_secret, "code": code, "redirect_uri": cb_uri},
+                            headers={"Accept": "application/json"}
+                        )
+                        token_data = token_resp.json()
+                        access_token = token_data.get("access_token")
+                        if not access_token:
+                            return JSONResponse({"error": "Failed to get access token", "detail": token_data}, status_code=400)
+
+                        # 获取用户信息
+                        user_resp = await client.get(
+                            "https://api.github.com/user",
+                            headers={"Authorization": f"Bearer {access_token}", "Accept": "application/json"}
+                        )
+                        user_data = user_resp.json()
+                        user_info = {
+                            "id": str(user_data.get("id", "")),
+                            "name": user_data.get("name") or user_data.get("login", ""),
+                            "email": user_data.get("email", ""),
+                            "provider": "github",
+                        }
+
+                    elif provider == "google":
+                        token_resp = await client.post(
+                            "https://oauth2.googleapis.com/token",
+                            data={"client_id": client_id, "client_secret": client_secret, "code": code, "redirect_uri": cb_uri, "grant_type": "authorization_code"}
+                        )
+                        token_data = token_resp.json()
+                        access_token = token_data.get("access_token")
+                        if not access_token:
+                            return JSONResponse({"error": "Failed to get access token", "detail": token_data}, status_code=400)
+
+                        user_resp = await client.get(
+                            "https://www.googleapis.com/oauth2/v2/userinfo",
+                            headers={"Authorization": f"Bearer {access_token}"}
+                        )
+                        user_data = user_resp.json()
+                        user_info = {
+                            "id": user_data.get("id", ""),
+                            "name": user_data.get("name", ""),
+                            "email": user_data.get("email", ""),
+                            "provider": "google",
+                        }
+                    else:
+                        return JSONResponse({"error": f"Unsupported provider: {provider}"}, status_code=400)
+
+            except httpx.HTTPError as e:
+                return JSONResponse({"error": f"OAuth exchange failed: {e}"}, status_code=502)
+
+            # 生成一次性 auth_ticket
+            ticket = server.oauth_manager.generate_auth_ticket(provider, user_info)
+
+            # 返回 ticket（前端用此 ticket 通过 WebSocket 认证）
+            redirect_uri = state_info.get("redirect_uri", "")
+            if redirect_uri:
+                # 重定向回前端，附带 ticket
+                from urllib.parse import urlencode
+                sep = "&" if "?" in redirect_uri else "?"
+                return JSONResponse(
+                    {"redirect": f"{redirect_uri}{sep}{urlencode({'auth_ticket': ticket})}"},
+                    status_code=200
+                )
+
+            return JSONResponse({"auth_ticket": ticket})
+
+        # 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)
+        set_proxy_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
+
+    # ── system.require_init 处理 ──
+
+    async def _do_init(self, ws):
+        """收到 system.require_init 后执行：订阅 + 注册 + module.ready"""
+        reason = "startup" if not self._has_registered else "recovery"
+        print(f"Received system.require_init (reason={reason})")
+
+        try:
+            # 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",
+                ],
+            })
+
+            # Register to Kernel
+            elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
+            elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
+            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",
+                "display": {
+                    "urls": {
+                        "Kite 控制台": f"http://127.0.0.1:{self.port}"
+                    }
+                },
+                "tools": {
+                    "rpc": {
+                        "module": {
+                            "health": {"method": "health", "description": "健康检查"},
+                            "status": {"method": "status", "description": "状态查询"}
+                        },
+                        "console": {
+                            "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 令牌"},
+                            "llm_sessions_list": {"method": "llm_sessions_list", "description": "列出 LLM 会话"},
+                            "llm_sessions_get": {"method": "llm_sessions_get", "description": "获取 LLM 会话详情"},
+                            "llm_sessions_save": {"method": "llm_sessions_save", "description": "保存 LLM 会话"},
+                            "llm_sessions_delete": {"method": "llm_sessions_delete", "description": "删除 LLM 会话"},
+                            "llm_sessions_sync": {"method": "llm_sessions_sync", "description": "同步 LLM 会话"},
+                            "get_system_context": {"method": "get_system_context", "description": "获取系统上下文（CLAUDE.md + module.md + 注册中心）"},
+                            "chat": {"method": "chat", "description": "LLM 聊天（转发到大模型 API）"},
+                            "file_read": {
+                                "method": "file_read",
+                                "description": "读取项目文件内容（路径限制在项目目录内）",
+                                "parameters": {
+                                    "type": "object",
+                                    "properties": {
+                                        "path": {"type": "string", "description": "文件路径（相对项目根目录）"},
+                                        "lines": {"type": "number", "description": "最大读取行数（默认 200）"}
+                                    },
+                                    "required": ["path"]
+                                }
+                            },
+                            "llm_config_get": {"method": "llm_config_get", "description": "获取 LLM 测试配置"},
+                            "llm_config_save": {"method": "llm_config_save", "description": "保存 LLM 测试配置"}
+                        }
+                    }
+                },
+                "events_publish": {
+                    "kite_console": {
+                        "test": {"description": "Test event from kite_console module"},
+                        "started": {"description": "Kite Console UI started with access URL"},
+                        "chat.chunk": {"description": "LLM chat response chunk (or final result)"},
+                    }
+                },
+                "events_subscribe": [
+                    "module.started",
+                    "module.stopped",
+                    "module.crashed",
+                    "module.ready",
+                    "module.exiting",
+                    "module.shutdown",
+                    "module.shutdown.ack",
+                    "module.shutdown.ready",
+                ],
+            })
+            print(f"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._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"module.ready published ({elapsed_str})")
+
+                # Publish kite_console.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, "kite_console.started", {
+                    "module_id": self.module_name,
+                    "url": access_url,
+                    "host": self.host,
+                    "port": self.port,
+                })
+
+            self._has_registered = True
+
+            # 通知 relay kernel 已上线（模块完成注册，可以接受客户端连接）
+            relay = getattr(self, 'relay', None)
+            if relay:
+                asyncio.create_task(relay.set_kernel_offline(False))
+
+        except Exception as e:
+            print(f"_do_init failed: {e}")
+
+    # ── Kernel WebSocket client ──
+
+    async def _ws_loop(self):
+        retry_delay = 0.5
+        max_delay = 10.0
+        attempt = 0
+        cooldown_attempts = 0
+        conn_refused_count = 0
+
+        while not self._shutting_down:
+            try:
+                await self._ws_connect()
+                retry_delay = 0.5
+                attempt = 0
+                cooldown_attempts = 0
+                conn_refused_count = 0
+                self._kernel_reconnect_info = {"state": "connected", "attempt": 0, "max_attempts": 10, "next_retry_ms": 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._kernel_reconnect_info = {"state": "fatal", "attempt": 0, "max_attempts": 0, "next_retry_ms": 0}
+                    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._kernel_reconnect_info = {"state": "fatal", "attempt": cooldown_attempts, "max_attempts": 5, "next_retry_ms": 0}
+                        self._exit_code = 1
+                        self._shutting_down = True
+                        if self._uvicorn_server:
+                            self._uvicorn_server.should_exit = True
+                        return
+                    self._kernel_reconnect_info = {"state": "cooldown", "attempt": cooldown_attempts, "max_attempts": 5, "next_retry_ms": 10000}
+                    self._update_relay_reconnect_info()
+                    print(f"\033[33m速率限制，10.0s 后重试 ({cooldown_attempts}/5)\033[0m")
+                    await asyncio.sleep(10.0)
+                    continue
+
+                # 连接被拒绝/重置 — Kernel 可能正在关闭
+                # Windows 的 [WinError 1225] 是 OSError 不是 ConnectionRefusedError
+                _is_conn_refused = isinstance(e, (ConnectionRefusedError, ConnectionResetError))
+                if not _is_conn_refused and isinstance(e, OSError) and getattr(e, 'winerror', None) == 1225:
+                    _is_conn_refused = True
+                if _is_conn_refused:
+                    conn_refused_count += 1
+                    if conn_refused_count >= 3:
+                        print(f"Kernel 持续不可达 ({conn_refused_count} 次)，正常退出")
+                        self._kernel_reconnect_info = {"state": "exiting", "attempt": conn_refused_count, "max_attempts": 3, "next_retry_ms": 0}
+                        self._shutting_down = True
+                        if self._uvicorn_server:
+                            self._uvicorn_server.should_exit = True
+                        return
+                    jitter = retry_delay * 0.2 * random.random()
+                    sleep_time = retry_delay + jitter
+                    self._kernel_reconnect_info = {"state": "reconnecting", "attempt": conn_refused_count, "max_attempts": 3, "next_retry_ms": int(sleep_time * 1000)}
+                    self._update_relay_reconnect_info()
+                    print(f"Kernel 连接失败: {type(e).__name__}, {sleep_time:.1f}s 后重试 ({conn_refused_count}/3)")
+                else:
+                    conn_refused_count = 0
+
+                    # 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")
+                    if attempt >= 10:
+                        print(f"连续 {attempt} 次连接失败，正常退出")
+                        self._kernel_reconnect_info = {"state": "exiting", "attempt": attempt, "max_attempts": 10, "next_retry_ms": 0}
+                        self._shutting_down = True
+                        if self._uvicorn_server:
+                            self._uvicorn_server.should_exit = True
+                        return
+                    self._kernel_reconnect_info = {"state": "reconnecting", "attempt": attempt, "max_attempts": 10, "next_retry_ms": int(sleep_time * 1000)}
+                    self._update_relay_reconnect_info()
+
+            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 _update_relay_reconnect_info(self):
+        """将当前 Kernel 重连状态同步到 relay"""
+        relay = getattr(self, 'relay', None)
+        if relay:
+            relay.kernel_reconnect_info = self._kernel_reconnect_info.copy()
+
+    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
+
+                    if has_method and not has_id:
+                        # 检测 system.require_init 事件
+                        params = msg.get("params", {})
+                        event_type = params.get("event", "")
+                        if event_type == "system.require_init":
+                            asyncio.create_task(self._do_init(ws))
+                            continue
+                        # 事件通知也需要异步处理，避免阻塞接收循环
+                        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"消息处理异常（已忽略）: {e}")
+        except Exception as e:
+            print(f"Receive loop exited with exception: {e}")
+        finally:
+            print(f"Receive loop ended")
+
+    async def _ws_connect(self):
+        url = f"ws://127.0.0.1:{self.kernel_port}/ws?id={self.module_name}"
+        print(f"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"Connected to Kernel{elapsed_str}")
+
+                # 启动接收循环（后台任务，等待 system.require_init 触发 _do_init）
+                receiver_task = asyncio.create_task(self._ws_receiver(ws))
+                print(f"Receiver task started")
+
+                try:
+                    # 等待接收循环结束（连接断开）
+                    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"\033[31mWebSocket connection error: {e}\033[0m")
+            raise
+        finally:
+            print(f"WebSocket connection closed")
+            self._ws = None
+            # 通知 relay kernel 离线（先同步重连状态）
+            relay = getattr(self, 'relay', None)
+            if relay:
+                relay.kernel_reconnect_info = self._kernel_reconnect_info.copy()
+                asyncio.create_task(relay.set_kernel_offline(True))
+            # 清理所有未完成的 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 + result/error）"""
+        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()
+
+        if self._ws:
+            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", {})
+
+        # 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
+
+        print(f"Event received: {event_type}, data: {data}")
+
+        if event_type == "module.shutdown":
+            target = data.get("module_id", "")
+            reason = data.get("reason", "")
+            if target == self.module_name 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"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("console."):
+            method = method[8:]
+
+        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),
+            "llm_sessions_list": lambda p: self._rpc_llm_sessions_list(p),
+            "llm_sessions_get": lambda p: self._rpc_llm_sessions_get(p),
+            "llm_sessions_save": lambda p: self._rpc_llm_sessions_save(p),
+            "llm_sessions_delete": lambda p: self._rpc_llm_sessions_delete(p),
+            "llm_sessions_sync": lambda p: self._rpc_llm_sessions_sync(p),
+            "get_system_context": lambda p: self._rpc_get_system_context(p),
+            "chat": lambda p: self._rpc_chat(p),
+            "file_read": lambda p: self._rpc_file_read(p),
+            "llm_config_get": lambda p: self._rpc_llm_config_get(p),
+            "llm_config_save": lambda p: self._rpc_llm_config_save(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": self.module_name,
+            "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_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"]
+        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)
+
+        return {"success": True, "msg": "已退出登录"}
+
+    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
+        await self._rpc_call(self._ws, "event.subscribe", {"events": events}, wait_response=False)
+
+        print(f"Subscribed to events: {events}")
+        return {"success": True, "events": events}
+
+    # ---- LLM Sessions RPC ----
+
+    def _get_phone_from_params(self, params: dict) -> str:
+        """从 params 中获取手机号，优先用 kiteToken 解析"""
+        kite_token = params.get("kiteToken", "")
+        if kite_token:
+            phone = self.auth_manager.get_phone_by_kite_token(kite_token)
+            if phone:
+                return phone
+        phone = params.get("phone", "")
+        if not phone:
+            raise ValueError("Missing phone or kiteToken")
+        return phone
+
+    def _sessions_dir(self, phone: str) -> Path:
+        """获取用户会话存储目录"""
+        data_dir = os.environ.get("KITE_DATA", os.path.expanduser("~/.kite/data"))
+        d = Path(data_dir) / "llm_sessions" / phone
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def _read_sessions_index(self, phone: str) -> list:
+        """读取会话索引"""
+        f = self._sessions_dir(phone) / "sessions.json"
+        if f.exists():
+            try:
+                return json.loads(f.read_text(encoding="utf-8"))
+            except Exception:
+                return []
+        return []
+
+    def _write_sessions_index(self, phone: str, sessions: list):
+        """写入会话索引"""
+        f = self._sessions_dir(phone) / "sessions.json"
+        f.write_text(json.dumps(sessions, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    async def _rpc_llm_sessions_list(self, params: dict) -> dict:
+        """列出用户的所有会话（仅元数据）"""
+        phone = self._get_phone_from_params(params)
+        sessions = self._read_sessions_index(phone)
+        return {"success": True, "data": sessions}
+
+    async def _rpc_llm_sessions_get(self, params: dict) -> dict:
+        """获取单个会话的完整消息"""
+        phone = self._get_phone_from_params(params)
+        session_id = params.get("session_id", "")
+        if not session_id:
+            raise ValueError("Missing session_id")
+
+        f = self._sessions_dir(phone) / f"{session_id}.json"
+        if not f.exists():
+            return {"success": False, "error": "Session not found"}
+
+        try:
+            data = json.loads(f.read_text(encoding="utf-8"))
+            return {"success": True, "data": data}
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    async def _rpc_llm_sessions_save(self, params: dict) -> dict:
+        """保存会话（创建或更新）"""
+        phone = self._get_phone_from_params(params)
+        session = params.get("session")
+        if not session or not session.get("id"):
+            raise ValueError("Missing session or session.id")
+
+        now = datetime.now(timezone.utc).isoformat()
+        session["updated_at"] = now
+        if not session.get("created_at"):
+            session["created_at"] = now
+
+        # 写入会话文件
+        d = self._sessions_dir(phone)
+        session_file = d / f"{session['id']}.json"
+        session_file.write_text(json.dumps(session, ensure_ascii=False, indent=2), encoding="utf-8")
+
+        # 更新索引
+        sessions = self._read_sessions_index(phone)
+        meta = {
+            "id": session["id"],
+            "name": session.get("name", ""),
+            "created_at": session.get("created_at", now),
+            "updated_at": session["updated_at"],
+            "message_count": len(session.get("messages", []))
+        }
+        idx = next((i for i, s in enumerate(sessions) if s["id"] == session["id"]), None)
+        if idx is not None:
+            sessions[idx] = meta
+        else:
+            sessions.insert(0, meta)
+        self._write_sessions_index(phone, sessions)
+
+        return {"success": True, "data": meta}
+
+    async def _rpc_llm_sessions_delete(self, params: dict) -> dict:
+        """删除会话"""
+        phone = self._get_phone_from_params(params)
+        session_id = params.get("session_id", "")
+        if not session_id:
+            raise ValueError("Missing session_id")
+
+        d = self._sessions_dir(phone)
+        session_file = d / f"{session_id}.json"
+        if session_file.exists():
+            session_file.unlink()
+
+        sessions = self._read_sessions_index(phone)
+        sessions = [s for s in sessions if s["id"] != session_id]
+        self._write_sessions_index(phone, sessions)
+
+        return {"success": True}
+
+    async def _rpc_llm_sessions_sync(self, params: dict) -> dict:
+        """同步会话 — 比较前后端时间戳"""
+        phone = self._get_phone_from_params(params)
+        local_sessions = params.get("sessions", [])
+
+        server_sessions = self._read_sessions_index(phone)
+        server_map = {s["id"]: s for s in server_sessions}
+        local_map = {s["id"]: s for s in local_sessions}
+
+        to_upload = []
+        to_download = []
+
+        for loc in local_sessions:
+            srv = server_map.get(loc["id"])
+            if not srv or loc.get("updated_at", "") > srv.get("updated_at", ""):
+                to_upload.append(loc["id"])
+
+        for srv in server_sessions:
+            loc = local_map.get(srv["id"])
+            if not loc or srv.get("updated_at", "") > loc.get("updated_at", ""):
+                to_download.append(srv["id"])
+
+        return {
+            "success": True,
+            "data": {
+                "to_upload": to_upload,
+                "to_download": to_download,
+                "server_sessions": server_sessions
+            }
+        }
+
+    async def _rpc_get_system_context(self, params: dict) -> dict:
+        """获取系统上下文（CLAUDE.md + module.md + 注册中心）"""
+        context = {
+            "claude_md": {"content": "", "bytes": 0},
+            "modules": [],
+            "registry": {"content": "", "bytes": 0, "tools_count": 0},
+            "total_bytes": 0
+        }
+
+        # 1. 读取 CLAUDE.md
+        root_dir = Path(os.environ.get("KITE_ROOT_DIR", "."))
+        claude_md_path = root_dir / "CLAUDE.md"
+        if claude_md_path.exists():
+            try:
+                content = claude_md_path.read_text(encoding="utf-8")
+                context["claude_md"]["content"] = content
+                context["claude_md"]["bytes"] = len(content.encode("utf-8"))
+            except Exception as e:
+                logger.warning(f"Failed to read CLAUDE.md: {e}")
+
+        # 2. 获取注册中心信息（registry.lookup 无参数 = 列出所有在线模块）
+        try:
+            lookup_resp = await self._rpc_call(self._ws, "registry.lookup", {})
+            lookup_result = lookup_resp.get("result", {})
+            module_ids = [r["module"] for r in lookup_result.get("results", [])]
+
+            modules_data = []
+            tools_data = []
+            for mid in module_ids:
+                try:
+                    get_resp = await self._rpc_call(self._ws, "registry.get", {"path": mid})
+                    get_result = get_resp.get("result", {})
+                    mod_data = get_result.get("value", {})
+                    modules_data.append({
+                        "module_id": mid,
+                        "module_type": mod_data.get("module_type", "unknown"),
+                        "status": mod_data.get("status", "unknown"),
+                    })
+                    mod_tools = mod_data.get("tools", {})
+                    if mod_tools:
+                        tools_data.append({"module_id": mid, "tools": mod_tools})
+                except Exception:
+                    modules_data.append({"module_id": mid, "status": "unknown"})
+
+            registry_content = json.dumps({"modules": modules_data, "tools": tools_data}, ensure_ascii=False, indent=2)
+            context["registry"]["content"] = registry_content
+            context["registry"]["bytes"] = len(registry_content.encode("utf-8"))
+            context["registry"]["tools_count"] = len(tools_data)
+
+            # 3. 读取每个模块的 module.md（搜索多个可能的路径）
+            for mid in module_ids:
+                candidates = [
+                    root_dir / mid / "module.md",
+                    root_dir / "extensions" / "services" / mid / "module.md",
+                    root_dir / "extensions" / "agents" / mid / "module.md",
+                    root_dir / "extensions" / "channels" / mid / "module.md",
+                    root_dir / "extensions" / mid / "module.md",
+                ]
+                for md_path in candidates:
+                    if md_path.exists():
+                        try:
+                            content = md_path.read_text(encoding="utf-8")
+                            context["modules"].append({
+                                "module_id": mid,
+                                "content": content,
+                                "bytes": len(content.encode("utf-8"))
+                            })
+                        except Exception as e:
+                            logger.warning(f"Failed to read {mid}/module.md: {e}")
+                        break
+        except Exception as e:
+            logger.warning(f"Failed to get registry info: {e}")
+
+        # 计算总字节数
+        context["total_bytes"] = (
+            context["claude_md"]["bytes"] +
+            context["registry"]["bytes"] +
+            sum(m["bytes"] for m in context["modules"])
+        )
+
+        return {"success": True, "data": context}
+
+    async def _rpc_llm_config_get(self, params: dict) -> dict:
+        """获取 LLM 测试配置"""
+        phone = self._get_phone_from_params(params)
+        config_path = self._sessions_dir(phone) / "config.json"
+
+        if config_path.exists():
+            try:
+                data = json.loads(config_path.read_text(encoding="utf-8"))
+                return {"success": True, "data": data}
+            except Exception as e:
+                logger.warning(f"Failed to read LLM config: {e}")
+
+        return {"success": True, "data": {}}
+
+    async def _rpc_llm_config_save(self, params: dict) -> dict:
+        """保存 LLM 测试配置"""
+        phone = self._get_phone_from_params(params)
+        config = params.get("config", {})
+
+        sessions_dir = self._sessions_dir(phone)
+        sessions_dir.mkdir(parents=True, exist_ok=True)
+
+        config_path = sessions_dir / "config.json"
+        config_path.write_text(json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8")
+
+        return {"success": True}
+
+    async def _rpc_chat(self, params: dict) -> dict:
+        """LLM 聊天 — 异步事件机制，RPC 立即返回 request_id"""
+        request_id = str(uuid.uuid4())[:8]
+
+        messages = params.get("messages", [])
+        model = params.get("model", "gpt-3.5-turbo")
+        base_url = params.get("base_url", "https://api.openai.com/v1")
+        api_key = params.get("api_key", "")
+        temperature = params.get("temperature", 0.7)
+        max_tokens = params.get("max_tokens", 1024)
+        tools = params.get("tools")
+
+        logger.info(f"[LLM Chat] 收到请求 {request_id}: model={model}, messages={len(messages)}, tools={len(tools) if tools else 0}")
+
+        if not api_key:
+            return {"success": False, "error": "API key is required"}
+
+        # 启动后台任务处理 LLM 调用
+        asyncio.create_task(self._chat_worker(
+            request_id, messages, model, base_url, api_key,
+            temperature, max_tokens, tools
+        ))
+
+        return {"success": True, "data": {"request_id": request_id}}
+
+    async def _chat_worker(self, request_id: str, messages: list, model: str,
+                           base_url: str, api_key: str, temperature: float,
+                           max_tokens: int, tools: list | None):
+        """后台执行 LLM 调用，通过事件推送结果"""
+        import httpx
+
+        # 发送 status=processing 事件
+        await self._publish_chat_event(request_id, "processing", {"message": "正在调用模型..."})
+
+        # 启动心跳：每 5 秒发一次 processing 事件
+        heartbeat_running = True
+
+        async def heartbeat():
+            elapsed = 0
+            while heartbeat_running:
+                await asyncio.sleep(5)
+                elapsed += 5
+                if heartbeat_running:
+                    await self._publish_chat_event(request_id, "processing", {
+                        "message": f"等待模型响应... ({elapsed}s)"
+                    })
+
+        heartbeat_task = asyncio.create_task(heartbeat())
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+
+        if tools:
+            payload["tools"] = tools
+
+        # 保存上下文到文件
+        debug_dir = Path("data/llm_debug")
+        debug_dir.mkdir(parents=True, exist_ok=True)
+        debug_file = debug_dir / f"{request_id}.json"
+        try:
+            debug_file.write_text(json.dumps({
+                "request_id": request_id,
+                "timestamp": time.time(),
+                "model": model,
+                "base_url": base_url,
+                "payload": payload
+            }, ensure_ascii=False, indent=2), encoding="utf-8")
+            logger.info(f"[LLM Chat] {request_id} 上下文已保存: {debug_file}")
+        except Exception as e:
+            logger.warning(f"[LLM Chat] {request_id} 保存上下文失败: {e}")
+
+        try:
+            url_base = base_url.rstrip('/')
+            if not url_base.endswith('/v1'):
+                url_base += '/v1'
+            api_url = f"{url_base}/chat/completions"
+            logger.info(f"[LLM Chat] {request_id} 调用 API: {api_url}")
+
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                response = await client.post(
+                    api_url,
+                    json=payload,
+                    headers={"Authorization": f"Bearer {api_key}"}
+                )
+                response.raise_for_status()
+                result = response.json()
+
+                has_tool_calls = bool(result["choices"][0]["message"].get("tool_calls"))
+                logger.info(f"[LLM Chat] {request_id} 调用成功: has_tool_calls={has_tool_calls}, usage={result.get('usage')}")
+
+                # 发送 status=done 事件
+                heartbeat_running = False
+                heartbeat_task.cancel()
+                await self._publish_chat_event(request_id, "done", {
+                    "content": result["choices"][0]["message"].get("content", ""),
+                    "tool_calls": result["choices"][0]["message"].get("tool_calls"),
+                    "usage": result.get("usage")
+                })
+
+        except Exception as e:
+            heartbeat_running = False
+            heartbeat_task.cancel()
+            logger.error(f"[LLM Chat] {request_id} 调用失败: {e}")
+            await self._publish_chat_event(request_id, "error", {"error": str(e)})
+
+    async def _publish_chat_event(self, request_id: str, status: str, data: dict):
+        """发布 chat 事件"""
+        if not self._ws:
+            return
+        await self._publish_event(self._ws, "kite_console.chat.chunk", {
+            "request_id": request_id,
+            "status": status,
+            **data
+        })
+
+    async def _rpc_file_read(self, params: dict) -> dict:
+        """读取项目文件（路径限制在项目目录内）"""
+        path = params.get("path", "")
+        max_lines = params.get("lines", 200)
+        if not path:
+            return {"success": False, "error": "缺少 path 参数"}
+
+        root_dir = Path(os.environ.get("KITE_ROOT_DIR", ".")).resolve()
+        target = (root_dir / path).resolve()
+        if not str(target).startswith(str(root_dir)):
+            return {"success": False, "error": "路径超出项目目录"}
+        if not target.exists():
+            return {"success": False, "error": f"文件不存在: {path}"}
+
+        try:
+            all_lines = target.read_text(encoding="utf-8").splitlines()
+            if max_lines and len(all_lines) > max_lines:
+                content = "\n".join(all_lines[:max_lines]) + f"\n\n... (截断，共 {len(all_lines)} 行)"
+            else:
+                content = "\n".join(all_lines)
+            return {"success": True, "data": {"content": content, "total_lines": len(all_lines)}}
+        except Exception as e:
+            return {"success": False, "error": f"读取失败: {e}"}
+
+    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"[kite_console] Slot {slot} connected")
+        except Exception as e:
+            print(f"[kite_console] Slot {slot} connect failed: {e}")
+
+    async def _slot_recv_loop(self, slot, ws):
+        """附加连接的接收循环：与主连接平等处理所有消息。"""
+        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"[kite_console] Slot {slot} 消息处理异常: {e}")
+        except Exception as e:
+            print(f"[kite_console] Slot {slot} 接收循环异常: {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(f"Received module.shutdown")
+        self._shutting_down = True
+
+        # 使用短超时发送 shutdown 事件，避免阻塞
+        try:
+            if self._ws:
+                await self._publish_event(self._ws, "module.shutdown.ack", {
+                    "module_id": self.module_name,
+                })
+        except Exception as e:
+            print(f"\033[31mFailed to send shutdown.ack: {e}\033[0m")
+
+        try:
+            if self._ws:
+                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"\033[31mFailed to send module.exiting: {e}\033[0m")
+
+        # Send shutdown.ready（必须在关闭连接之前发送）
+        try:
+            if self._ws:
+                await self._publish_event(self._ws, "module.shutdown.ready", {
+                    "module_id": self.module_name,
+                })
+        except Exception as e:
+            print(f"\033[31mFailed to send shutdown.ready: {e}\033[0m")
+
+        # 等待 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(f"Relay service close timeout")
+            except Exception as e:
+                print(f"\033[31mFailed to close relay sessions: {e}\033[0m")
+
+        # 关闭所有附加连接
+        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 连接
+        # 先清理未完成的 RPC future
+        for fut in self._pending_rpc.values():
+            if not fut.done():
+                fut.cancel()
+        self._pending_rpc.clear()
+
+        if self._ws:
+            try:
+                await self._ws.close(code=1000, reason="Graceful shutdown")
+                print(f"Kernel WebSocket closed")
+            except Exception as e:
+                print(f"\033[31mFailed to close Kernel WebSocket: {e}\033[0m")
+
+        # 触发 uvicorn 优雅关闭（让 uvicorn 自然退出，不要 sys.exit）
+        if self._uvicorn_server:
+            print(f"Triggering uvicorn graceful shutdown")
+            self._uvicorn_server.should_exit = True
+        else:
+            print(f"\033[31mWarning: uvicorn_server not set\033[0m")
+
+    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 _test_event_loop(self):
+        try:
+            while True:
+                await asyncio.sleep(10)
+                if self._ws:
+                    await self._publish_event(self._ws, "kite_console.test", {
+                        "message": "test event from kite_console",
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                    })
+        except Exception:
+            pass