@agentunion/kite 1.0.7 → 1.3.0

package/kernel/server.py

@@ -0,0 +1,267 @@
+"""
+Kernel unified server.
+FastAPI app with WebSocket endpoint (RPC + Event) and minimal HTTP endpoints (/health, /stats).
+Merges Registry + Event Hub into a single process.
+"""
+
+import asyncio
+import json
+import os
+
+from fastapi import FastAPI
+from starlette.websockets import WebSocket, WebSocketDisconnect
+
+from .registry_store import RegistryStore
+from .event_hub import EventHub
+from .rpc_router import RpcRouter
+
+try:
+    import orjson
+    def _loads(raw: str):
+        return orjson.loads(raw)
+except ImportError:
+    def _loads(raw: str):
+        return json.loads(raw)
+
+
+class KernelServer:
+    """Merged Registry + Event Hub server.
+
+    Single WebSocket endpoint handles:
+    - JSON-RPC 2.0 requests (builtin + cross-module forward)
+    - JSON-RPC 2.0 responses (from forwarded calls)
+    - Event notifications (delivered to subscribers)
+    """
+
+    def __init__(self, launcher_token: str = None, advertise_ip: str = "127.0.0.1"):
+        self.advertise_ip = advertise_ip
+        self.port: int = 0  # set by entry.py before uvicorn.run
+
+        # Core components
+        self.registry = RegistryStore(launcher_token)  # Can be None
+        self.event_hub = EventHub()
+
+        # Shared connection table (module_id -> WebSocket)
+        # RpcRouter and EventHub both reference this
+        self.connections: dict[str, WebSocket] = {}
+
+        # RPC router (pass self reference)
+        self.rpc_router = RpcRouter(
+            self.registry,
+            self.event_hub,
+            self.connections,
+            kernel_server=self
+        )
+
+        # Background tasks
+        self._ttl_task: asyncio.Task | None = None
+        self._dedup_task: asyncio.Task | None = None
+        self._uvicorn_server = None  # set by entry.py for graceful shutdown
+        self._shutting_down = False
+
+        # Launcher connection tracking
+        self._launcher_connected = False
+        self._launcher_subscribed = False
+        self._ready_published = False
+
+        # Build FastAPI app
+        self.app = self._create_app()
+
+    # ── App factory ──
+
+    def _create_app(self) -> FastAPI:
+        app = FastAPI(title="Kite Kernel", docs_url=None, redoc_url=None)
+        server = self
+
+        @app.on_event("startup")
+        async def _startup():
+            server._ttl_task = asyncio.create_task(server._ttl_loop())
+            server._dedup_task = asyncio.create_task(server._dedup_loop())
+
+        @app.on_event("shutdown")
+        async def _shutdown():
+            if server._ttl_task:
+                server._ttl_task.cancel()
+            if server._dedup_task:
+                server._dedup_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", "")
+
+            # Token verification (all modules including Launcher need token)
+            module_id = server.registry.verify_token(token)
+            if module_id is None:
+                # Must accept before close (Starlette requirement)
+                await ws.accept()
+                print(f"[kernel] Auth failed: token={token[:8]}... hint={mid_hint}")
+                try:
+                    await ws.close(code=4001, reason="Authentication failed")
+                except Exception:
+                    pass
+                return
+
+            # Use id hint for debug mode
+            if module_id == "debug" and mid_hint:
+                module_id = mid_hint
+
+            await ws.accept()
+
+            # Register connection in both EventHub and shared connections table
+            server.event_hub.add_connection(module_id, ws)
+            server.connections[module_id] = ws
+
+            # Track Launcher connection
+            if module_id == "launcher":
+                server._launcher_connected = True
+                print(f"[kernel] launcher connected")
+
+            # Renew heartbeat on connect
+            if module_id in server.registry.modules:
+                server.registry.heartbeat(module_id)
+
+            try:
+                while True:
+                    raw = await ws.receive_text()
+                    try:
+                        msg = _loads(raw)
+                    except Exception:
+                        # JSON parse error — send error if there's an id
+                        try:
+                            await ws.send_text(json.dumps({
+                                "jsonrpc": "2.0", "id": None,
+                                "error": {"code": -32700, "message": "Parse error"}
+                            }))
+                        except Exception:
+                            pass
+                        continue
+
+                    if not isinstance(msg, dict):
+                        continue
+
+                    # Classify message type:
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+                    has_result = "result" in msg
+                    has_error = "error" in msg
+
+                    if has_method and has_id:
+                        # RPC Request → dispatch to handler
+                        await server.rpc_router.dispatch(module_id, ws, msg)
+                    elif has_id and (has_result or has_error):
+                        # RPC Response → match to pending forward
+                        await server.rpc_router.handle_response(module_id, msg)
+                    # else: notification or unknown — ignore
+
+            except WebSocketDisconnect:
+                pass
+            except Exception as e:
+                err = str(e).lower()
+                if "not connected" not in err and "closed" not in err:
+                    print(f"[kernel] WebSocket error for {module_id}: {e}")
+            finally:
+                # Cleanup
+                server.event_hub.remove_connection(module_id)
+                server.connections.pop(module_id, None)
+                server.registry.set_offline(module_id)
+                server.event_hub.publish_internal(
+                    "module.offline", {"module_id": module_id})
+
+        # ── HTTP endpoints (debug only) ──
+
+        @app.get("/health")
+        async def health():
+            eh_health = server.event_hub.get_health()
+            return {
+                "status": "healthy",
+                "module_count": len(server.registry.modules),
+                "online_count": sum(
+                    1 for m in server.registry.modules.values()
+                    if m.get("status") == "online"
+                ),
+                "event_stats": eh_health.get("details", {}),
+            }
+
+        @app.get("/stats")
+        async def stats():
+            return {
+                "registry": {
+                    "modules": {
+                        mid: {
+                            "status": data.get("status"),
+                            "module_type": data.get("module_type"),
+                            "registered_at": data.get("registered_at"),
+                        }
+                        for mid, data in server.registry.modules.items()
+                    },
+                },
+                "event_hub": server.event_hub.get_stats(),
+            }
+
+        return app
+
+    # ── Background loops ──
+
+    async def _ttl_loop(self):
+        """Check heartbeat TTL every 10s and publish offline events."""
+        while True:
+            await asyncio.sleep(10)
+            try:
+                expired = self.registry.check_ttl()
+                for mid in expired:
+                    self.event_hub.publish_internal(
+                        "module.offline", {"module_id": mid})
+            except Exception as e:
+                print(f"[kernel] TTL loop error: {e}")
+
+    async def _dedup_loop(self):
+        """Clean up dedup table every 30s."""
+        while True:
+            await asyncio.sleep(30)
+            try:
+                await asyncio.get_event_loop().run_in_executor(
+                    None, self.event_hub.dedup.cleanup)
+            except Exception as e:
+                print(f"[kernel] Dedup cleanup error: {e}")
+
+    # ── Self-registration ──
+
+    def self_register(self):
+        """Register Kernel itself in the registry (in-memory, no RPC needed)."""
+        self.registry.register_module({
+            "module_id": "kernel",
+            "module_type": "infrastructure",
+            "api_endpoint": f"http://{self.advertise_ip}:{self.port}",
+            "health_endpoint": "/health",
+            "metadata": {
+                "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
+            },
+        })
+
+    def publish_ready(self):
+        """Publish module.ready event for Kernel (internal, no WS needed)."""
+        self.event_hub.publish_internal("module.ready", {
+            "module_id": "kernel",
+            "ws_endpoint": f"ws://{self.advertise_ip}:{self.port}/ws",
+            "graceful_shutdown": True,
+        })
+
+    async def shutdown(self):
+        """Shutdown Kernel gracefully. Called by Launcher via RPC."""
+        if self._shutting_down:
+            return
+
+        self._shutting_down = True
+        print("[kernel] Shutting down...")
+
+        # Brief delay to ensure RPC response is sent
+        await asyncio.sleep(0.1)
+
+        # Trigger uvicorn shutdown
+        if self._uvicorn_server:
+            self._uvicorn_server.should_exit = True
+        else:
+            print("[kernel] Warning: uvicorn server reference not set")

package/launcher/__init__.py

@@ -0,0 +1,10 @@
+"""
+Launcher package — Kite system entry point.
+
+Can be started in two ways:
+1. Via main.py (with code stats): python main.py
+2. Directly (no stats): python -m launcher
+"""
+from .entry import start_launcher
+
+__all__ = ["start_launcher"]

package/launcher/__main__.py

@@ -0,0 +1,6 @@
+"""
+Direct launcher entry point: python -m launcher
+"""
+if __name__ == "__main__":
+    from .entry import start_launcher
+    start_launcher()

package/launcher/count_lines.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""
+代码行数统计工具
+统计 Kite 项目的代码行数并记录到 JSONL 文件
+"""
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# Enable ANSI colors on Windows
+if sys.platform == "win32":
+    try:
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+    except Exception:
+        pass
+
+
+def count_lines_in_file(file_path: Path) -> int:
+    """统计单个文件的行数"""
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            return sum(1 for _ in f)
+    except Exception:
+        return 0
+
+
+def count_lines(root_dir: Path, pattern: str, exclude_dirs: set[str]) -> int:
+    """统计指定模式的文件行数"""
+    total = 0
+    for file_path in root_dir.rglob(pattern):
+        # 检查是否在排除目录中
+        if any(excluded in file_path.parts for excluded in exclude_dirs):
+            continue
+        total += count_lines_in_file(file_path)
+    return total
+
+
+def count_all(root_dir: Path) -> dict:
+    """统计所有类型的代码行数"""
+    stats = {}
+
+    # 排除的目录
+    exclude_dirs = {
+        "__pycache__",
+        "node_modules",
+        ".git",
+        ".venv",
+        "venv",
+        ".idea",
+        ".vscode",
+        ".dev",          # 开发相关（变更日志、发布备份）
+        ".claude",       # Claude 工作目录
+    }
+
+    # Python 代码
+    stats["python"] = count_lines(root_dir, "*.py", exclude_dirs)
+
+    # JavaScript 代码
+    stats["javascript"] = count_lines(root_dir, "*.js", exclude_dirs)
+
+    # Markdown 文档
+    stats["markdown"] = count_lines(root_dir, "*.md", exclude_dirs)
+
+    # YAML 配置
+    stats["yaml"] = count_lines(root_dir, "*.yaml", exclude_dirs) + \
+                    count_lines(root_dir, "*.yml", exclude_dirs)
+
+    # JSON 配置（排除 package-lock.json）
+    json_total = 0
+    for file_path in root_dir.rglob("*.json"):
+        if any(excluded in file_path.parts for excluded in exclude_dirs):
+            continue
+        if file_path.name == "package-lock.json":
+            continue
+        json_total += count_lines_in_file(file_path)
+    stats["json"] = json_total
+
+    # 总计
+    stats["total"] = sum(stats.values())
+
+    return stats
+
+
+def save_record(stats: dict, record_file: Path):
+    """保存统计记录到 JSONL 文件（仅在有变化时）"""
+    # 读取最后一条记录
+    last_stats = None
+    if record_file.exists():
+        try:
+            with open(record_file, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+                if lines:
+                    last_record = json.loads(lines[-1])
+                    last_stats = last_record.get("stats")
+        except (json.JSONDecodeError, IndexError):
+            pass
+
+    # 如果统计结果与上次完全相同，跳过保存
+    if last_stats == stats:
+        return
+
+    record = {
+        "timestamp": datetime.now().isoformat(),
+        "stats": stats,
+    }
+
+    # 追加到 JSONL 文件
+    record_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(record_file, "a", encoding="utf-8") as f:
+        f.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+
+def print_stats(stats: dict):
+    """打印统计结果"""
+    # ANSI 颜色代码
+    BOLD = "\033[1m"
+    RESET = "\033[0m"
+
+    print("\n" + "=" * 50)
+    print("Kite 项目代码统计")
+    print("=" * 50)
+    print(f"Python 代码:      {BOLD}{stats['python']:>8,} 行{RESET}")
+    print(f"JavaScript 代码:  {BOLD}{stats['javascript']:>8,} 行{RESET}")
+    print(f"Markdown 文档:    {BOLD}{stats['markdown']:>8,} 行{RESET}")
+    print(f"YAML 配置:        {BOLD}{stats['yaml']:>8,} 行{RESET}")
+    print(f"JSON 配置:        {BOLD}{stats['json']:>8,} 行{RESET}")
+    print("-" * 50)
+    print(f"总计:             {BOLD}{stats['total']:>8,} 行{RESET}")
+    print("=" * 50 + "\n")
+
+
+def show_history(record_file: Path, limit: int = 10):
+    """显示历史记录"""
+    # ANSI 颜色代码
+    GREEN = "\033[32m"
+    RED = "\033[31m"
+    BOLD = "\033[1m"
+    RESET = "\033[0m"
+
+    if not record_file.exists():
+        print("暂无历史记录")
+        return
+
+    records = []
+    with open(record_file, "r", encoding="utf-8") as f:
+        for line in f:
+            try:
+                records.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+
+    if not records:
+        print("暂无历史记录")
+        return
+
+    print("\n" + "=" * 80)
+    print("历史记录（最近 {} 次）".format(min(limit, len(records))))
+    print("=" * 80)
+    print(f"{'时间':<25} {'Python':>10} {'JS':>10} {'MD':>10} {'总计':>10} {'变化':>10}")
+    print("-" * 80)
+
+    recent = records[-limit:]
+    for i, record in enumerate(recent):
+        ts = record["timestamp"][:19].replace("T", " ")
+        stats = record["stats"]
+
+        # 计算与上一次的变化
+        if i > 0:
+            prev_total = recent[i-1]["stats"]["total"]
+            diff = stats["total"] - prev_total
+            if diff > 0:
+                diff_str = f"{GREEN}+{diff:,}{RESET}"
+            elif diff < 0:
+                diff_str = f"{RED}{diff:,}{RESET}"
+            else:
+                diff_str = "0"
+        else:
+            diff_str = "-"
+
+        print(f"{ts:<25} {stats['python']:>10,} {stats['javascript']:>10,} "
+              f"{stats['markdown']:>10,} {BOLD}{stats['total']:>10,}{RESET} {diff_str:>10}")
+
+    print("=" * 80 + "\n")
+
+
+def run_stats():
+    """Run code stats from main.py entry point (simplified output)."""
+    script_dir = Path(__file__).parent
+    root_dir = script_dir.parent
+    record_file = root_dir / "data" / "stats" / "lines.jsonl"
+
+    print("[launcher] 正在统计代码行数...")
+    try:
+        stats = count_all(root_dir)
+        save_record(stats, record_file)
+
+        # Print stats
+        BRIGHT_GREEN = "\033[92m"
+        BOLD = "\033[1m"
+        RESET = "\033[0m"
+
+        print("")
+        print("=" * 50)
+        print("Kite 项目代码统计")
+        print("=" * 50)
+        print(f"Python 代码:      {BRIGHT_GREEN}{stats['python']:>8,}{RESET} 行")
+        print(f"JavaScript 代码:  {BRIGHT_GREEN}{stats['javascript']:>8,}{RESET} 行")
+        print(f"Markdown 文档:    {BRIGHT_GREEN}{stats['markdown']:>8,}{RESET} 行")
+        print(f"YAML 配置:        {BRIGHT_GREEN}{stats['yaml']:>8,}{RESET} 行")
+        print(f"JSON 配置:        {BRIGHT_GREEN}{stats['json']:>8,}{RESET} 行")
+        print("-" * 50)
+        print(f"总计:             {BOLD}{BRIGHT_GREEN}{stats['total']:>8,}{RESET} 行")
+        print("=" * 50)
+        print("")
+
+        # Show history trend (last 8 records)
+        show_history(record_file, limit=8)
+    except Exception as e:
+        print(f"[launcher] 统计异常: {e}")
+
+
+def main():
+    # 获取项目根目录
+    script_dir = Path(__file__).parent
+    root_dir = script_dir.parent
+
+    # 记录文件路径
+    record_file = root_dir / "data" / "stats" / "lines.jsonl"
+
+    # 解析命令行参数
+    show_hist = "--history" in sys.argv or "-h" in sys.argv
+    quiet = "--quiet" in sys.argv or "-q" in sys.argv
+
+    if show_hist:
+        # 只显示历史记录
+        show_history(record_file)
+        return
+
+    # 统计代码行数
+    if not quiet:
+        print("正在统计代码行数...")
+    stats = count_all(root_dir)
+
+    # 保存记录
+    save_record(stats, record_file)
+
+    # 打印结果
+    if not quiet:
+        print_stats(stats)
+        # 显示最近 8 次记录
+        show_history(record_file, limit=8)
+
+
+if __name__ == "__main__":
+    main()