@agentunion/kite 1.0.7 → 1.3.0

package/core/event_hub/entry.py

@@ -1,157 +0,0 @@
-"""
-Event Hub entry point.
-Reads token from stdin boot_info, reads launcher_ws_token from stdin second line,
-starts FastAPI server, outputs ws_endpoint via stdout, waits for Launcher to connect,
-then registers to Registry after stdio disconnect.
-"""
-
-import json
-import os
-import re
-import socket
-import sys
-import threading
-
-import uvicorn
-
-# Ensure project root is on sys.path (set by main.py or cli.js)
-_this_dir = os.path.dirname(os.path.abspath(__file__))
-_project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirname(_this_dir))
-if _project_root not in sys.path:
-    sys.path.insert(0, _project_root)
-
-from core.event_hub.hub import EventHub
-from core.event_hub.server import EventHubServer
-
-
-def _read_module_md() -> dict:
-    """Read preferred_port, advertise_ip from own module.md."""
-    md_path = os.path.join(_this_dir, "module.md")
-    result = {"preferred_port": 0, "advertise_ip": "127.0.0.1"}
-    try:
-        with open(md_path, encoding="utf-8") as f:
-            text = f.read()
-        m = re.match(r'^---\s*\n(.*?)\n---', text, re.DOTALL)
-        if m:
-            try:
-                import yaml
-                fm = yaml.safe_load(m.group(1)) or {}
-            except ImportError:
-                fm = {}
-            result["preferred_port"] = int(fm.get("preferred_port", 0))
-            result["advertise_ip"] = fm.get("advertise_ip", "127.0.0.1")
-    except Exception:
-        pass
-    return result
-
-
-def _bind_port(preferred: int, host: str) -> int:
-    """Try preferred port first, fall back to OS-assigned."""
-    if preferred:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind((host, preferred))
-                return preferred
-        except OSError:
-            pass
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind((host, 0))
-        return s.getsockname()[1]
-
-
-def _read_stdin_kite_message() -> dict | None:
-    """Read a structured kite message from stdin (second line after boot_info).
-    Uses a short timeout thread to avoid blocking forever if Launcher doesn't send.
-    """
-    result = [None]
-
-    def _read():
-        try:
-            line = sys.stdin.readline().strip()
-            if line:
-                msg = json.loads(line)
-                if isinstance(msg, dict) and "kite" in msg:
-                    result[0] = msg
-        except Exception:
-            pass
-
-    t = threading.Thread(target=_read, daemon=True)
-    t.start()
-    t.join(timeout=5)
-    return result[0]
-
-
-def main():
-    # Kite environment
-    kite_instance = os.environ.get("KITE_INSTANCE", "")
-    is_debug = os.environ.get("KITE_DEBUG") == "1"
-
-    # Step 1: Read token from stdin boot_info
-    token = ""
-    try:
-        line = sys.stdin.readline().strip()
-        if line:
-            boot_info = json.loads(line)
-            token = boot_info.get("token", "")
-    except Exception:
-        pass
-
-    if not token:
-        print("[event_hub] 错误: boot_info 中缺少令牌")
-        sys.exit(1)
-
-    # Step 2: Read launcher_ws_token from stdin (second line, structured kite message)
-    launcher_ws_token = ""
-    kite_msg = _read_stdin_kite_message()
-    if kite_msg and kite_msg.get("kite") == "launcher_ws_token":
-        launcher_ws_token = kite_msg.get("launcher_ws_token", "")
-
-    if launcher_ws_token:
-        print(f"[event_hub] 已收到启动器 WS 令牌 ({len(launcher_ws_token)} 字符)")
-    else:
-        print("[event_hub] 警告: 未收到 launcher_ws_token，启动器引导认证已禁用")
-
-    # Step 3: Read registry_port from environment variable
-    registry_port = int(os.environ.get("KITE_REGISTRY_PORT", "0"))
-    if not registry_port:
-        print("[event_hub] 错误: KITE_REGISTRY_PORT 未设置")
-        sys.exit(1)
-
-    print(f"[event_hub] 已收到令牌 ({len(token)} 字符)，Registry 端口: {registry_port}")
-
-    # Step 4: Read config from own module.md
-    md_config = _read_module_md()
-    advertise_ip = md_config["advertise_ip"]
-    preferred_port = md_config["preferred_port"]
-
-    # Step 5: Bind port and create server
-    bind_host = advertise_ip
-    port = _bind_port(preferred_port, bind_host)
-    registry_url = f"http://127.0.0.1:{registry_port}"
-
-    if is_debug:
-        print("[event_hub] 调试模式已启用 (KITE_DEBUG=1)，接受所有令牌")
-
-    hub = EventHub()
-    server = EventHubServer(
-        hub,
-        own_token=token,
-        registry_url=registry_url,
-        launcher_ws_token=launcher_ws_token,
-        advertise_ip=advertise_ip,
-        port=port,
-    )
-
-    # Step 6: Output ws_endpoint via stdout (Launcher reads this)
-    ws_endpoint = f"ws://{advertise_ip}:{port}/ws"
-    print(json.dumps({"kite": "ws_endpoint", "ws_endpoint": ws_endpoint}), flush=True)
-
-    # Step 7: Start HTTP + WS server
-    # Launcher will connect with launcher_ws_token → Event Hub sends module.ready → stdio disconnect
-    # After stdio disconnect, Event Hub registers to Registry (done by server on_launcher_connected callback)
-    print(f"[event_hub] 启动中 {bind_host}:{port}")
-    uvicorn.run(server.app, host=bind_host, port=port, log_level="warning")
-
-
-if __name__ == "__main__":
-    main()

package/core/event_hub/module.md

@@ -1,20 +0,0 @@
----
-name: event_hub
-display_name: Event Hub
-version: "1.0"
-type: infrastructure
-state: enabled
-runtime: python
-entry: entry.py
-events: []
-subscriptions: []
----
-
-# Event Hub
-
-Kite 系统的实时事件路由器。
-
-- 接收模块通过 WebSocket 发送的事件
-- 根据订阅关系（支持 NATS 风格通配符）转发给匹配的模块
-- 事件去重（1h 滑动窗口）防止 outbox 重放导致重复转发
-- ACK 确认机制，模块据此清理本地 outbox

package/core/event_hub/server.py

@@ -1,206 +0,0 @@
-"""
-Event Hub HTTP + WebSocket server.
-FastAPI app: /ws (WebSocket), /health, /stats.
-30s timer for heartbeat renewal + dedup cleanup.
-
-Launcher bootstrap sequence:
-  Launcher connects with launcher_ws_token → Event Hub verifies locally →
-  sends module.ready → registers to Registry.
-"""
-
-import asyncio
-import json
-import os
-import uuid
-from datetime import datetime, timezone
-
-import httpx
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-
-from .hub import EventHub
-
-
-class EventHubServer:
-
-    def __init__(self, hub: EventHub, own_token: str, registry_url: str,
-                 launcher_ws_token: str = "",
-                 advertise_ip: str = "127.0.0.1", port: int = 0):
-        self.hub = hub
-        self.own_token = own_token
-        self.registry_url = registry_url
-        self.is_debug = os.environ.get("KITE_DEBUG") == "1"
-        self.launcher_ws_token = launcher_ws_token
-        self.advertise_ip = advertise_ip
-        self.port = port
-        self._timer_task: asyncio.Task | None = None
-        self._launcher_connected = False
-        self._registered_to_registry = False
-        self.app = self._create_app()
-
-    # ── Token verification ──
-
-    async def _verify_token(self, token: str, module_id_hint: str = "") -> str | None:
-        """Verify a token. Launcher's launcher_ws_token is verified locally.
-        Other tokens are verified via Registry POST /verify.
-        In debug mode (KITE_DEBUG=1), any non-empty token is accepted."""
-        if self.is_debug and token:
-            return module_id_hint or "debug"
-        # Local verification for Launcher bootstrap (before Registry registration)
-        if self.launcher_ws_token and token == self.launcher_ws_token:
-            return "launcher"
-        # Normal verification via Registry
-        try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.post(
-                    f"{self.registry_url}/verify",
-                    json={"token": token},
-                    headers={"Authorization": f"Bearer {self.own_token}"},
-                    timeout=5,
-                )
-                if resp.status_code == 200:
-                    body = resp.json()
-                    if body.get("ok"):
-                        return body.get("module_id")
-        except Exception as e:
-            print(f"[event_hub] Token verification failed: {e}")
-        return None
-
-    # ── Launcher bootstrap ──
-
-    async def _on_launcher_connected(self, ws: WebSocket):
-        """Called on first Launcher WS connect. Sends module.ready, then registers to Registry."""
-        self._launcher_connected = True
-        msg = {
-            "type": "event",
-            "event_id": str(uuid.uuid4()),
-            "event": "module.ready",
-            "source": "event_hub",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "data": {
-                "module_id": "event_hub",
-                "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
-            },
-        }
-        try:
-            await ws.send_text(json.dumps(msg))
-            print("[event_hub] Sent module.ready to Launcher")
-        except Exception as e:
-            print(f"[event_hub] Failed to send module.ready: {e}")
-        # Register to Registry in background
-        asyncio.create_task(self._register_to_registry())
-
-    async def _register_to_registry(self):
-        """Register to Registry. Triggered after Launcher connects."""
-        if self._registered_to_registry:
-            return
-        payload = {
-            "action": "register",
-            "module_id": "event_hub",
-            "module_type": "infrastructure",
-            "name": "Event Hub",
-            "api_endpoint": f"http://{self.advertise_ip}:{self.port}",
-            "health_endpoint": "/health",
-            "metadata": {
-                "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
-            },
-        }
-        headers = {"Authorization": f"Bearer {self.own_token}"}
-        try:
-            async with httpx.AsyncClient() as client:
-                resp = await client.post(
-                    f"{self.registry_url}/modules",
-                    json=payload,
-                    headers=headers,
-                    timeout=5,
-                )
-                if resp.status_code == 200:
-                    self._registered_to_registry = True
-                    print("[event_hub] Registered to Registry")
-                else:
-                    print(f"[event_hub] WARNING: Registry returned {resp.status_code}")
-        except Exception as e:
-            print(f"[event_hub] WARNING: Failed to register to Registry: {e}")
-
-    # ── App factory ──
-
-    def _create_app(self) -> FastAPI:
-        app = FastAPI(title="Kite Event Hub", docs_url=None, redoc_url=None)
-        server = self
-
-        @app.on_event("startup")
-        async def _startup():
-            server._timer_task = asyncio.create_task(server._timer_loop())
-
-        @app.on_event("shutdown")
-        async def _shutdown():
-            if server._timer_task:
-                server._timer_task.cancel()
-
-        # ── WebSocket endpoint ──
-
-        @app.websocket("/ws")
-        async def ws_endpoint(ws: WebSocket):
-            token = ws.query_params.get("token", "")
-            mid_hint = ws.query_params.get("id", "")
-            module_id = await server._verify_token(token, mid_hint)
-            if not module_id:
-                # Must accept before close — Starlette drops TCP without close frame otherwise,
-                # causing websockets 15.x clients to get "no close frame received or sent" errors.
-                await ws.accept()
-                print(f"[event_hub] 认证失败: token={token[:8]}... hint={mid_hint}")
-                await ws.close(code=4001, reason="Authentication failed")
-                return
-
-            await ws.accept()
-            server.hub.add_connection(module_id, ws)
-
-            # Launcher bootstrap: first connection triggers module.ready + Registry registration
-            if (module_id == "launcher"
-                    and not server._launcher_connected
-                    and server.launcher_ws_token
-                    and token == server.launcher_ws_token):
-                await server._on_launcher_connected(ws)
-
-            try:
-                while True:
-                    raw = await ws.receive_text()
-                    await server.hub.handle_message(module_id, ws, raw)
-            except WebSocketDisconnect:
-                pass
-            except Exception as e:
-                print(f"[event_hub] WebSocket error for {module_id}: {e}")
-            finally:
-                server.hub.remove_connection(module_id)
-
-        # ── HTTP endpoints ──
-
-        @app.get("/health")
-        async def health():
-            return server.hub.get_health()
-
-        @app.get("/stats")
-        async def stats():
-            return server.hub.get_stats()
-
-        return app
-
-    # ── 30s timer: heartbeat + dedup cleanup ──
-
-    async def _timer_loop(self):
-        while True:
-            await asyncio.sleep(30)
-            await asyncio.get_event_loop().run_in_executor(None, self.hub.dedup.cleanup)
-            if self._registered_to_registry:
-                await self._heartbeat()
-
-    async def _heartbeat(self):
-        try:
-            async with httpx.AsyncClient() as client:
-                await client.post(
-                    f"{self.registry_url}/modules",
-                    json={"action": "heartbeat", "module_id": "event_hub"},
-                    headers={"Authorization": f"Bearer {self.own_token}"},
-                    timeout=5,
-                )
-        except Exception:
-            pass