@agentunion/kite 1.3.2 → 1.5.0

package/extensions/services/evol/relay_config.json5

@@ -0,0 +1,67 @@
+{
+  // 中转服务配置
+  relay: {
+    // 基础模块 ID（实际 module_id 会加上 session 后缀）
+    base_module_id: "evol-client",
+
+    // 重连超时时间（秒）
+    // 前端刷新页面或短暂断网时，中转服务保持 Kernel 连接的时长
+    reconnect_timeout: 6,
+
+    // WebSocket 端点路径
+    endpoint: "/ws/relay"
+  },
+
+  // 认证配置
+  auth: {
+    // frontend_token 有效期（秒，30天）
+    token_expiry: 2592000,
+
+    // token 续期阈值（秒，7天）
+    // 当 token 剩余有效期小于此值时，自动续期
+    token_renew_threshold: 604800,
+
+    // 配对码长度
+    pairing_code_length: 6,
+
+    // 配对码文件路径（相对于模块数据目录）
+    pairing_code_file: "pairing_codes.jsonl"
+  },
+
+  // 权限配置（基于角色的 RPC 白名单）
+  permissions: {
+    // 管理员角色 - 完全权限
+    admin: [
+      "event.*",              // 事件订阅（必需）
+      "registry.*",           // 注册表查询（必需）
+      "launcher.*",           // 所有 launcher RPC
+      "kernel.health",        // Kernel 健康检查
+      "kernel.stats",         // Kernel 统计信息
+      "*.health",             // 所有模块的健康检查
+      "*.status",             // 所有模块的状态查询
+      "watchdog.*",           // Watchdog 相关
+      "backup.*",             // Backup 相关
+      "model_service.*",      // Model Service 相关
+      "web.*"                 // Web 管理相关（token 管理等）
+    ],
+
+    // 操作员角色 - 模块管理权限
+    operator: [
+      "event.*",              // 事件订阅（必需）
+      "launcher.list_modules",
+      "launcher.start_module",
+      "launcher.stop_module",
+      "launcher.restart_module",
+      "*.health",
+      "*.status"
+    ],
+
+    // 查看者角色 - 只读权限
+    viewer: [
+      "event.*",              // 事件订阅（必需）
+      "launcher.list_modules",
+      "*.health",
+      "*.status"
+    ]
+  }
+}

package/extensions/services/evol/routes/__init__.py

@@ -0,0 +1 @@
+

package/extensions/services/evol/routes/routes_management_ws.py

@@ -0,0 +1,127 @@
+"""Management WebSocket — 实时推送模块状态变更到前端管理页面"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from datetime import datetime, timezone
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# 全局连接池 — 所有连接的管理客户端
+_management_clients: set[WebSocket] = set()
+
+
+@router.websocket("/ws/management")
+async def management_websocket(ws: WebSocket):
+    """
+    管理后台实时状态推送 WebSocket.
+
+    前端连接后会收到：
+    - 初始 connected 消息
+    - 模块状态变更事件（module.started, module.stopped, module.crashed 等）
+    - 健康检查结果（module.health）
+    - Kernel 连接状态（module.connected, module.registered）
+    """
+    await ws.accept()
+    _management_clients.add(ws)
+    client_id = id(ws)
+    logger.info(f"Management WS: client connected (id={client_id}, total={len(_management_clients)})")
+
+    try:
+        # 发送初始连接确认
+        await ws.send_json({
+            "type": "connected",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+        })
+
+        # 保持连接，接收心跳和客户端消息
+        while True:
+            try:
+                raw = await asyncio.wait_for(ws.receive_text(), timeout=60.0)
+                msg = json.loads(raw)
+
+                # 心跳响应
+                if msg.get("type") == "ping":
+                    await ws.send_json({
+                        "type": "pong",
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
+                    })
+
+            except asyncio.TimeoutError:
+                # 60 秒无消息，发送 ping 检测连接
+                try:
+                    await ws.send_json({"type": "ping"})
+                except Exception:
+                    break
+
+    except WebSocketDisconnect:
+        logger.info(f"Management WS: client disconnected (id={client_id})")
+    except Exception as e:
+        logger.warning(f"Management WS: client error (id={client_id}): {e}")
+    finally:
+        _management_clients.discard(ws)
+        logger.info(f"Management WS: client removed (id={client_id}, remaining={len(_management_clients)})")
+
+
+async def broadcast_event(event_type: str, data: dict):
+    """
+    广播事件到所有连接的管理客户端.
+
+    Args:
+        event_type: 事件类型（如 module.started, module.stopped）
+        data: 事件数据（通常包含 module_id 等字段）
+    """
+    if not _management_clients:
+        return
+
+    message = {
+        "type": event_type,
+        "data": data,
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+
+    message_str = json.dumps(message)
+    dead_clients = []
+
+    # 并发发送到所有客户端
+    for ws in list(_management_clients):
+        try:
+            await ws.send_text(message_str)
+        except Exception as e:
+            logger.debug(f"Management WS: failed to send to client {id(ws)}: {e}")
+            dead_clients.append(ws)
+
+    # 清理失败的连接
+    for ws in dead_clients:
+        _management_clients.discard(ws)
+
+    if dead_clients:
+        logger.info(f"Management WS: removed {len(dead_clients)} dead clients, remaining={len(_management_clients)}")
+
+
+def get_client_count() -> int:
+    """返回当前连接的管理客户端数量"""
+    return len(_management_clients)
+
+
+async def close_all_clients():
+    """优雅关闭所有管理客户端（用于 shutdown）"""
+    if not _management_clients:
+        return
+
+    logger.info(f"Management WS: closing {len(_management_clients)} clients...")
+
+    for ws in list(_management_clients):
+        try:
+            await ws.close(code=1001, reason="Server shutting down")
+        except Exception as e:
+            logger.debug(f"Management WS: error closing client {id(ws)}: {e}")
+
+    _management_clients.clear()
+    logger.info("Management WS: all clients closed")

package/extensions/services/evol/routes/routes_rpc.py

@@ -0,0 +1,89 @@
+"""RPC forwarding routes — forward HTTP requests to Kernel RPC."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import uuid
+
+from fastapi import APIRouter, HTTPException, Request
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["rpc"])
+
+# Global reference to EvolServer instance (set by server.py)
+_evol_server = None
+
+
+def set_evol_server(server):
+    """Set the EvolServer instance for RPC forwarding."""
+    global _evol_server
+    _evol_server = server
+
+
+@router.post("/rpc/{method:path}")
+async def forward_rpc(method: str, request: Request):
+    """
+    Forward RPC call to Kernel via WebSocket.
+
+    Example:
+        POST /api/rpc/launcher.start_module
+        Body: {"name": "watchdog"}
+    """
+    if not _evol_server:
+        raise HTTPException(503, "Evol 模块未初始化")
+
+    if not _evol_server._ws:
+        raise HTTPException(503, "Evol 模块未连接到 Kernel，请检查 Kernel 是否正常运行")
+
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+
+    # Generate unique request ID
+    rpc_id = str(uuid.uuid4())
+
+    # Create RPC request
+    rpc_request = {
+        "jsonrpc": "2.0",
+        "id": rpc_id,
+        "method": method,
+        "params": body,
+    }
+
+    # Create a future to wait for response
+    response_future = asyncio.Future()
+
+    # Store the future in a dict (keyed by rpc_id)
+    if not hasattr(_evol_server, '_rpc_futures'):
+        _evol_server._rpc_futures = {}
+    _evol_server._rpc_futures[rpc_id] = response_future
+
+    # Send RPC request
+    try:
+        await _evol_server._ws.send(json.dumps(rpc_request))
+    except Exception as e:
+        _evol_server._rpc_futures.pop(rpc_id, None)
+        raise HTTPException(503, f"发送 RPC 请求失败: {str(e)}")
+
+    # Wait for response (with timeout)
+    try:
+        response = await asyncio.wait_for(response_future, timeout=30.0)
+    except asyncio.TimeoutError:
+        _evol_server._rpc_futures.pop(rpc_id, None)
+        raise HTTPException(504, f"RPC 请求超时（30秒），目标服务可能未响应")
+    finally:
+        _evol_server._rpc_futures.pop(rpc_id, None)
+
+    # Check for RPC error
+    if "error" in response:
+        error = response["error"]
+        error_msg = error.get('message', '未知错误')
+        error_code = error.get('code', -1)
+        raise HTTPException(500, f"RPC 调用失败: {error_msg} (code: {error_code})")
+
+    # Return result
+    return response.get("result", {})

package/extensions/services/evol/routes/routes_test.py

@@ -0,0 +1,61 @@
+"""
+测试日志 API 路由
+"""
+import os
+from datetime import datetime
+from pathlib import Path
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter()
+
+
+class TestLogRequest(BaseModel):
+    """测试日志请求"""
+    content: str
+    test_name: str = "registry_test"
+
+
+@router.post("/save_test_log")
+async def save_test_log(req: TestLogRequest):
+    """
+    保存测试日志到服务器
+
+    日志保存路径: {KITE_MODULE_DATA}/log/registry_test.log (每次覆盖)
+    """
+    try:
+        # 获取模块数据目录
+        module_data = os.environ.get("KITE_MODULE_DATA")
+        if not module_data:
+            raise HTTPException(status_code=500, detail="KITE_MODULE_DATA not set")
+
+        # 日志保存到 log 目录（与 latest.log 同级）
+        log_dir = Path(module_data) / "log"
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        # 固定文件名，每次覆盖
+        log_file = log_dir / "registry_test.log"
+
+        # 写入日志（覆盖模式）
+        now = datetime.now()
+        with open(log_file, "w", encoding="utf-8") as f:
+            f.write(f"# Kite 注册中心测试日志\n")
+            f.write(f"# 测试时间: {now.isoformat()}\n")
+            f.write(f"# {'=' * 70}\n\n")
+            f.write(req.content)
+
+        # 输出到控制台（会被 Launcher 捕获）
+        print(f"\n{'=' * 70}")
+        print(f"[evol] 测试日志已保存")
+        print(f"[evol] 路径: {log_file}")
+        print(f"[evol] 时间: {now.strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"{'=' * 70}\n")
+
+        return {
+            "success": True,
+            "log_path": str(log_file),
+            "timestamp": now.isoformat()
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to save log: {str(e)}")