@agentunion/kite 1.3.2 → 1.5.0

package/extensions/services/proxy/server.py

@@ -0,0 +1,271 @@
+"""
+server.py - 精简版 FastAPI 服务器
+
+仅提供4个代理路由 + 健康检查：
+- /claude-proxy/{path}  - Claude代理（仅 v1/messages 路径且 model 包含 "claude"）
+- /codex-proxy/{path}   - Codex代理（不做 model 过滤）
+- /gemini-proxy/{path}  - Gemini代理（不做 model 过滤）
+- /openclaw-proxy/{path} - OpenClaw代理（OpenAI兼容接口）
+- /health               - 健康检查
+"""
+
+import asyncio
+import json
+import logging
+import threading
+import time
+import uuid
+
+import uvicorn
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, Response
+
+
+# ==================== 并发管理器 ====================
+
+class ConcurrencyLimitManager:
+    """管理代理接口的总并发数，带自动清理超时请求"""
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._active_requests = {}
+        self._count_lock = threading.Lock()
+        self._timeout_seconds = 300
+        self._limit = 5
+        print("[ConcurrencyLimitManager] initialized")
+
+    def acquire(self) -> tuple:
+        with self._count_lock:
+            self._cleanup_timeout_requests()
+            request_id = f"req_{int(time.time() * 1000)}_{id(threading.current_thread())}"
+            self._active_requests[request_id] = time.time()
+            return True, "", request_id
+
+    def release(self, request_id: str = None):
+        with self._count_lock:
+            if request_id and request_id in self._active_requests:
+                del self._active_requests[request_id]
+            elif not request_id and self._active_requests:
+                oldest_id = min(self._active_requests, key=self._active_requests.get)
+                del self._active_requests[oldest_id]
+
+    def _cleanup_timeout_requests(self):
+        current_time = time.time()
+        timeout_ids = [
+            rid for rid, t in self._active_requests.items()
+            if current_time - t > self._timeout_seconds
+        ]
+        for rid in timeout_ids:
+            del self._active_requests[rid]
+
+    def get_current_count(self) -> int:
+        with self._count_lock:
+            return len(self._active_requests)
+
+
+concurrency_manager = ConcurrencyLimitManager()
+
+
+# ==================== FastAPI 应用 ====================
+
+app = FastAPI(title="Evol Sample Backend", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ==================== 健康检查 ====================
+
+@app.get("/health")
+async def health_check():
+    from evol.server.claude_proxy_async import get_current_agent_id
+    agent_id = get_current_agent_id()
+    return {
+        "status": "ok",
+        "agent_id": agent_id.id if agent_id else None,
+        "is_online": agent_id.is_online_success if agent_id else False,
+        "active_requests": concurrency_manager.get_current_count()
+    }
+
+
+# ==================== Claude Proxy 路由 ====================
+
+@app.api_route("/claude-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def claude_proxy_route(request: Request, full_path: str):
+    """Claude代理路由 - 仅放行 v1/messages 路径且 model 包含 'claude'"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    if "v1/messages" not in full_path:
+        concurrency_manager.release(request_id)
+        raise HTTPException(status_code=200, detail="OK")
+
+    try:
+        request_body = await request.body()
+        bodyjson = await asyncio.to_thread(json.loads, request_body.decode('utf-8'))
+        model = bodyjson.get('model', '')
+        if "claude" not in model:
+            raise HTTPException(status_code=400, detail="Unsupported model")
+
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("claude-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== Codex Proxy 路由 ====================
+
+@app.api_route("/codex-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def codex_proxy_route(request: Request, full_path: str):
+    """Codex代理路由 - 不做 model 过滤"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    try:
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("codex-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== Gemini Proxy 路由 ====================
+
+@app.api_route("/gemini-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def gemini_proxy_route(request: Request, full_path: str):
+    """Gemini代理路由 - 不做 model 过滤"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    try:
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("gemini-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== OpenClaw Proxy 路由 ====================
+
+@app.api_route("/openclaw-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def openclaw_proxy_route(request: Request, full_path: str):
+    """OpenClaw代理路由 - OpenAI兼容接口"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        from evol.server.openclaw_proxy import openai_error_response
+        return openai_error_response(error_msg, error_type="rate_limit_exceeded", status_code=429)
+
+    try:
+        if full_path == "v1/models":
+            from evol.server.openclaw_proxy import get_models_list
+            return JSONResponse(get_models_list())
+        elif full_path == "v1/chat/completions":
+            from evol.server.openclaw_proxy import proxy_openclaw_request
+            response = await proxy_openclaw_request(request)
+            return response
+        else:
+            from evol.server.openclaw_proxy import openai_error_response
+            return openai_error_response(
+                f"Path not found: /{full_path}. Supported: /v1/models, /v1/chat/completions.",
+                error_type="invalid_request_error",
+                status_code=404
+            )
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("openclaw-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        from evol.server.openclaw_proxy import openai_error_response
+        return openai_error_response(f"Internal server error: {str(e)}", error_type="api_error", status_code=500)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== 启动服务器 ====================
+
+# 全局变量存储实际端口
+_actual_port = None
+
+def get_actual_port():
+    """获取服务器实际使用的端口"""
+    return _actual_port
+
+async def run_server(port: int = 0):
+    """启动 FastAPI 服务器
+
+    Args:
+        port: 端口号，0 表示系统自动分配
+    """
+    global _actual_port
+
+    # 如果端口为 0，先获取一个可用端口
+    if port == 0:
+        import socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.bind(('', 0))
+        port = sock.getsockname()[1]
+        sock.close()
+
+    _actual_port = port
+
+    config = uvicorn.Config(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info",
+        access_log=True,
+    )
+    server = uvicorn.Server(config)
+    server.install_signal_handlers = False  # 禁止 uvicorn 安装信号处理器，防止外部信号导致服务器关闭
+    await server.serve()

package/extensions/services/watchdog/entry.py

@@ -20,7 +20,113 @@ import websockets
 
 
 # ── Module configuration ──
-MODULE_NAME = "watchdog"
+
+def _load_module_config() -> dict:
+    """Load module configuration from module.md frontmatter.
+
+    Returns:
+        Dict with keys: name, preferred_port, advertise_ip
+
+    Raises:
+        SystemExit: If module.md is invalid or name is non-compliant
+    """
+    _this_dir = os.path.dirname(os.path.abspath(__file__))
+    module_md = os.path.join(_this_dir, "module.md")
+
+    # Calculate relative path for error messages
+    project_root = os.environ.get("KITE_PROJECT", "")
+    if project_root and _this_dir.startswith(project_root):
+        rel_path = os.path.relpath(_this_dir, project_root)
+    else:
+        rel_path = _this_dir
+
+    # Default values (will be overridden if valid config exists)
+    result = {
+        "name": "",
+        "preferred_port": 0,
+        "advertise_ip": "0.0.0.0"
+    }
+
+    # Check if module.md exists
+    if not os.path.exists(module_md):
+        print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+        print(f"  Path: {rel_path}/module.md")
+        print(f"  Reason: File not found")
+        sys.exit(1)
+
+    try:
+        with open(module_md, encoding="utf-8") as f:
+            text = f.read()
+
+        # Extract YAML frontmatter (between --- markers)
+        import re
+        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
+        if not m:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Missing YAML frontmatter")
+            sys.exit(1)
+
+        # Parse YAML frontmatter
+        try:
+            import yaml
+            fm = yaml.safe_load(m.group(1)) or {}
+        except ImportError:
+            print(f"[{rel_path}] ERROR: PyYAML not installed, cannot parse module.md")
+            sys.exit(1)
+        except Exception as e:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: YAML parse error: {e}")
+            sys.exit(1)
+
+        # Validate 'name' field (required)
+        if "name" not in fm:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Missing 'name' field")
+            sys.exit(1)
+
+        raw_name = str(fm["name"]).strip()
+
+        if not raw_name:
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Empty module name")
+            sys.exit(1)
+
+        # Validate name characters
+        sanitized = re.sub(r'[^a-zA-Z0-9_\-]', '', raw_name)
+
+        if sanitized != raw_name:
+            invalid_chars = ''.join(sorted(set(c for c in raw_name if c not in sanitized)))
+            print(f"[{rel_path}] ERROR: Invalid module configuration in module.md")
+            print(f"  Path: {rel_path}/module.md")
+            print(f"  Reason: Invalid characters in name '{raw_name}': {repr(invalid_chars)}")
+            sys.exit(1)
+
+        result["name"] = sanitized
+
+        # Extract optional fields
+        if "preferred_port" in fm:
+            try:
+                result["preferred_port"] = int(fm["preferred_port"])
+            except (ValueError, TypeError):
+                pass
+
+        if "advertise_ip" in fm:
+            result["advertise_ip"] = str(fm["advertise_ip"])
+
+    except SystemExit:
+        raise  # Re-raise exit to prevent catching by outer except
+    except Exception as e:
+        print(f"[{rel_path}] ERROR: Failed to read module.md: {e}")
+        sys.exit(1)
+
+    return result
+
+_module_config = _load_module_config()
+MODULE_NAME = _module_config["name"]
 
 
 def _fmt_elapsed(t0: float) -> str:
@@ -266,6 +372,7 @@ def _read_stdin_kite_message(expected_type: str, timeout: float = 10) -> dict |
 # Global WS reference for publish_event callback
 _ws_global = None
 _shutting_down = False
+_exit_code = 0  # Exit code for main() to use
 _monitor = None
 _monitor_task = None
 
@@ -347,7 +454,7 @@ async def main():
 
 async def _ws_loop(token: str, kernel_port: int, _t0: float):
     """Connect to Kernel with exponential backoff reconnection."""
-    global _shutting_down
+    global _shutting_down, _exit_code
     retry_delay = 0.3
     max_delay = 5.0
     max_retries = 10
@@ -363,12 +470,21 @@ async def _ws_loop(token: str, kernel_port: int, _t0: float):
             attempt += 1
             if _is_auth_failure(e):
                 print(f"[watchdog] Kernel 认证失败，退出")
-                sys.exit(1)
+                _exit_code = 1
+                _shutting_down = True
+                return
             if attempt >= max_retries:
                 print(f"[watchdog] 重连失败 {max_retries} 次，退出")
-                sys.exit(1)
+                _exit_code = 1
+                _shutting_down = True
+                return
             _write_crash(type(e), e, e.__traceback__, severity="error", handled=True)
             print(f"[watchdog] 连接错误: {e}, {retry_delay:.1f}s 后重试 ({attempt}/{max_retries})")
+            if attempt == 5:
+                print(f"\033[33m[watchdog] 提示: 已连续 {attempt} 次无法连接 Kernel (端口 {kernel_port})")
+                if kernel_port < 1024:
+                    print(f"[watchdog] ⚠ 端口 {kernel_port} 异常偏低，可能是 Kernel 端口绑定失败或配置错误")
+                print(f"[watchdog] 请检查: 1) Kernel 进程是否存活  2) kernel/module.md 中 preferred_port 配置是否正确\033[0m")
         _ws_global_clear()
         if _shutting_down:
             return
@@ -388,7 +504,7 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
     ws_url = f"ws://127.0.0.1:{kernel_port}/ws?token={token}&id=watchdog"
     print(f"[watchdog] Connecting to Kernel: {ws_url}")
 
-    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
+    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
         _ws_global = ws
         print(f"[watchdog] Connected to Kernel ({_fmt_elapsed(_t0)})")
 
@@ -410,10 +526,25 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
         await _rpc_call(ws, "registry.register", {
             "module_id": "watchdog",
             "module_type": "service",
+            "tools": {
+                "rpc": {
+                    "module": {
+                        "health": {"method": "health", "description": "健康检查"},
+                        "status": {"method": "status", "description": "状态查询"}
+                    }
+                }
+            },
             "events_publish": {
-                "watchdog.module.unhealthy": {},
-                "watchdog.module.recovered": {},
-                "watchdog.alert": {},
+                "watchdog": {
+                    "module": {
+                        "unhealthy": {"description": "模块不健康"},
+                        "recovered": {"description": "模块恢复"},
+                        "resource_critical": {"description": "资源严重不足"},
+                        "resource_warning": {"description": "资源警告"},
+                        "resource_recovered": {"description": "资源恢复正常"}
+                    },
+                    "alert": {"description": "监控告警"}
+                }
             },
             "events_subscribe": [
                 "system.ready",
@@ -433,12 +564,14 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
 
         # Publish module.ready (every reconnect)
         if not _shutting_down:
+            startup_time = time.monotonic() - _t0
             await _rpc_call(ws, "event.publish", {
                 "event_id": str(uuid.uuid4()),
                 "event": "module.ready",
                 "data": {
                     "module_id": "watchdog",
                     "graceful_shutdown": True,
+                    "startup_time": startup_time,
                 },
             })
             print(f"[watchdog] module.ready published ({_fmt_elapsed(_t0)})")
@@ -448,6 +581,11 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
             _monitor_task = asyncio.create_task(_monitor.run())
 
         # Message loop: handle incoming RPC + events
+        # CRITICAL: RPC 死锁防范
+        # - 入站 RPC 请求必须用 create_task() 异步执行，不可 await
+        # - 原因：如果 handler 内部调用 rpc_call_with_response() 发出站请求，出站响应需要本接收循环来分发
+        # - 如果接收循环被 await handler 阻塞，出站响应永远收不到 → 超时死锁
+        # - 事件通知和 RPC 响应可以同步处理（它们不会反向调用 rpc_call）
         async for raw in ws:
             try:
                 msg = json.loads(raw)
@@ -462,8 +600,8 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
                     # Event Notification
                     await _handle_event_notification(msg, _monitor)
                 elif has_method and has_id:
-                    # Incoming RPC request
-                    await _handle_rpc_request(ws, msg, _monitor)
+                    # Incoming RPC request — run in background to prevent deadlock
+                    asyncio.create_task(_handle_rpc_request(ws, msg, _monitor))
                 elif has_id and not has_method:
                     # RPC response — route to waiter
                     msg_id = msg["id"]
@@ -483,7 +621,16 @@ async def _rpc_call(ws, method: str, params: dict = None):
     await ws.send(json.dumps(msg))
 
 
-async def _rpc_call_with_response(ws, method: str, params: dict = None, timeout: float = 5) -> dict:
+async def _publish_event(ws, event: dict):
+    """Publish an event via RPC event.publish."""
+    await _rpc_call(ws, "event.publish", {
+        "event_id": str(uuid.uuid4()),
+        "event": event.get("event", ""),
+        "data": event.get("data", {}),
+    })
+
+
+async def _rpc_call_with_response(ws, method: str, params: dict = None, timeout: float = 5):
     """Send a JSON-RPC 2.0 request and await the response."""
     rpc_id = str(uuid.uuid4())
     msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
@@ -514,17 +661,41 @@ async def _publish_event(ws, event: dict):
     })
 
 
+async def _handle_ping_event(data: dict):
+    """Handle system.ping event and reply with system.pong."""
+    t1 = data.get("ping_time")
+    t2 = time.time()
+
+    await _publish_event(_ws_global, {
+        "event": "system.pong",
+        "data": {
+            "module_id": MODULE_NAME,
+            "ping_time": t1,
+            "pong_time": t2,
+        },
+    })
+
+
 async def _handle_event_notification(msg: dict, monitor: HealthMonitor):
     """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
     params = msg.get("params", {})
     event_type = params.get("event", "")
     data = params.get("data", {})
 
-    # Special handling for module.shutdown targeting watchdog
-    if event_type == "module.shutdown" and data.get("module_id") == "watchdog":
-        await _handle_shutdown(monitor)
+    # Handle system.ping event
+    if event_type == "system.ping":
+        await _handle_ping_event(data)
         return
 
+    # Debug: log all shutdown events
+    if event_type == "module.shutdown":
+        target = data.get("module_id", "")
+        reason = data.get("reason", "")
+        # Handle both targeted shutdown (module_id == "watchdog") and broadcast shutdown (no module_id or launcher_lost)
+        if target == "watchdog" or not target or reason == "launcher_lost":
+            await _handle_shutdown(monitor)
+            return
+
     # Forward to monitor (extract params from JSON-RPC notification)
     await monitor.handle_event(params)
 
@@ -558,11 +729,21 @@ async def _handle_rpc_request(ws, msg: dict, monitor: HealthMonitor):
 
 async def _rpc_health(monitor: HealthMonitor) -> dict:
     """RPC handler for watchdog.health."""
+    # 统计不健康的模块数量
+    unhealthy_count = sum(1 for s in monitor.modules.values() if s.state == "unhealthy")
+    # 统计资源严重不足的模块数量
+    critical_resources = sum(1 for s in monitor.modules.values() if s.resource_state == "critical")
+    # 统计总重启次数
+    total_restarts = sum(s.restarted_count for s in monitor.modules.values())
+
     return {
         "status": "healthy",
+        "uptime_seconds": round(time.time() - _start_ts),
         "details": {
             "monitored_modules": len(monitor.modules),
-            "uptime_seconds": round(time.time() - _start_ts),
+            "unhealthy_modules": unhealthy_count,
+            "critical_resources": critical_resources,
+            "total_restarts": total_restarts,
         },
     }
 
@@ -573,30 +754,38 @@ async def _rpc_status(monitor: HealthMonitor) -> dict:
 
 
 async def _handle_shutdown(monitor: HealthMonitor):
-    """Handle module.shutdown event — exiting → ack → cleanup → ready → exit."""
+    """Handle module.shutdown event — ack → exiting → cleanup → ready → exit."""
     global _shutting_down
     print("[watchdog] Received shutdown request")
     _shutting_down = True
-    # Step 0: Send module.exiting
+    # Step 1: Send ack (立即确认收到)
     await _publish_event(_ws_global, {
-        "event": "module.exiting",
-        "data": {"module_id": "watchdog", "action": "none"},
+        "event": "module.shutdown.ack",
+        "data": {"module_id": "watchdog"},
     })
-    # Step 1: Send ack
+    # Step 2: Send module.exiting (开始清理)
     await _publish_event(_ws_global, {
-        "event": "module.shutdown.ack",
-        "data": {"module_id": "watchdog", "estimated_cleanup": 2},
+        "event": "module.exiting",
+        "data": {
+            "module_id": "watchdog",
+            "type": "passive",
+            "reason": "shutdown_requested",
+            "restart": "auto",
+            "action": "none",
+            "timeout": 2.0,
+            "restart_delay": 0.0,
+        },
     })
-    # Step 2: Cleanup
+    # Step 3: Cleanup
     monitor.stop()
-    # Step 3: Send ready
+    # Step 4: Send ready (清理完成)
     await _publish_event(_ws_global, {
         "event": "module.shutdown.ready",
         "data": {"module_id": "watchdog"},
     })
     print("[watchdog] Shutdown ready, exiting")
-    # Step 4: Exit
-    sys.exit(0)
+    # Step 5: Exit
+    sys.exit(_exit_code)
 
 
 if __name__ == "__main__":

package/extensions/services/watchdog/module.md

@@ -6,6 +6,7 @@ type: service
 state: enabled
 runtime: python
 entry: entry.py
+display_order: 99
 events:
   - watchdog.module.unhealthy
   - watchdog.module.recovered