@agentunion/kite 1.3.2 → 1.4.0

package/extensions/services/web/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/web/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 WebServer instance (set by server.py)
+_web_server = None
+
+
+def set_web_server(server):
+    """Set the WebServer instance for RPC forwarding."""
+    global _web_server
+    _web_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 _web_server:
+        raise HTTPException(503, "Web 模块未初始化")
+
+    if not _web_server._ws:
+        raise HTTPException(503, "Web 模块未连接到 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(_web_server, '_rpc_futures'):
+        _web_server._rpc_futures = {}
+    _web_server._rpc_futures[rpc_id] = response_future
+
+    # Send RPC request
+    try:
+        await _web_server._ws.send(json.dumps(rpc_request))
+    except Exception as e:
+        _web_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:
+        _web_server._rpc_futures.pop(rpc_id, None)
+        raise HTTPException(504, f"RPC 请求超时（30秒），目标服务可能未响应")
+    finally:
+        _web_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/web/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"[web] 测试日志已保存")
+        print(f"[web] 路径: {log_file}")
+        print(f"[web] 时间: {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)}")

package/extensions/services/web/routes/schemas.py

@@ -214,25 +214,3 @@ class ConfigUpdate(BaseModel):
     """Arbitrary config update payload — accepts any key/value pairs."""
 
     model_config = {"extra": "allow"}
-
-
-# ---------------------------------------------------------------------------
-# Modules
-# ---------------------------------------------------------------------------
-
-class ModuleMetadataUpdate(BaseModel):
-    """可更新的 module.md frontmatter 字段."""
-    display_name: Optional[str] = None
-    version: Optional[str] = None
-    state: Optional[str] = None          # enabled | manual | disabled
-    preferred_port: Optional[int] = None
-    advertise_ip: Optional[str] = None
-    monitor: Optional[bool] = None
-    events: Optional[list[str]] = None
-    subscriptions: Optional[list[str]] = None
-    depends_on: Optional[list[str]] = None
-
-
-class ModuleConfigUpdate(BaseModel):
-    """config.yaml 更新，接受任意 key/value."""
-    model_config = {"extra": "allow"}