@agentunion/kite 1.5.0 → 1.6.1

package/extensions/event_hub_bench/entry.py

@@ -132,6 +132,12 @@ def _load_module_config() -> dict:
         if "advertise_ip" in fm:
             result["advertise_ip"] = str(fm["advertise_ip"])
 
+        # max_connections（弹性连接上限）
+        try:
+            result["max_connections"] = max(1, min(10, int(fm.get("max_connections", 1))))
+        except (ValueError, TypeError):
+            result["max_connections"] = 1
+
     except SystemExit:
         raise  # Re-raise exit to prevent catching by outer except
     except Exception as e:
@@ -377,12 +383,19 @@ class WsClient:
     """Lightweight async WebSocket client for Kernel benchmarks (JSON-RPC 2.0)."""
 
     def __init__(self, ws_url: str, token: str, client_id: str):
-        self.url = f"{ws_url}?token={token}&id={client_id}"
+        self.url = f"{ws_url}?id={client_id}"
+        self.token = token
         self.id = client_id
         self.ws = None
 
     async def connect(self):
         self.ws = await websockets.connect(self.url, max_size=None)
+        # First-message auth
+        auth_req = {"jsonrpc": "2.0", "id": "auth", "method": "auth", "params": {"token": self.token}}
+        await self.ws.send(json.dumps(auth_req))
+        auth_resp = json.loads(await asyncio.wait_for(self.ws.recv(), timeout=5))
+        if "error" in auth_resp:
+            raise Exception(f"Auth failed: {auth_resp['error']}")
 
     async def subscribe(self, patterns: list[str]):
         msg = {"jsonrpc": "2.0", "id": str(uuid.uuid4()), "method": "event.subscribe", "params": {"events": patterns}}
@@ -620,8 +633,17 @@ def _send_ready_event(ws_url: str, token: str):
     """Send module.ready to Kernel via JSON-RPC 2.0. Startup phase complete."""
     try:
         import websockets.sync.client as ws_sync
-        url = f"{ws_url}?token={token}&id=event_hub_bench"
+        url = f"{ws_url}?id=event_hub_bench"
         with ws_sync.connect(url, close_timeout=3) as ws:
+            # First-message auth
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": "auth",
+                "method": "auth", "params": {"token": token},
+            }))
+            auth_resp = json.loads(ws.recv(timeout=5))
+            if "error" in auth_resp:
+                print(f"{TAG} WARNING: Auth failed: {auth_resp['error']}")
+                return
             # Subscribe (先订阅)
             ws.send(json.dumps({
                 "jsonrpc": "2.0", "id": str(uuid.uuid4()),
@@ -635,6 +657,7 @@ def _send_ready_event(ws_url: str, token: str):
                     "module_id": "event_hub_bench",
                     "module_type": "tool",
                     "name": "Event Hub Benchmark",
+                    "max_connections": 1,
                 },
             }))
             # Publish ready
@@ -656,8 +679,17 @@ def _send_exiting_event(ws_url: str, token: str, reason: str):
     """Send module.exiting event to Kernel via JSON-RPC 2.0 before exit."""
     try:
         import websockets.sync.client as ws_sync
-        url = f"{ws_url}?token={token}&id=event_hub_bench"
+        url = f"{ws_url}?id=event_hub_bench"
         with ws_sync.connect(url, close_timeout=3) as ws:
+            # First-message auth
+            ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": "auth",
+                "method": "auth", "params": {"token": token},
+            }))
+            auth_resp = json.loads(ws.recv(timeout=5))
+            if "error" in auth_resp:
+                print(f"{TAG} WARNING: Auth failed: {auth_resp['error']}")
+                return
             ws.send(json.dumps({
                 "jsonrpc": "2.0", "id": str(uuid.uuid4()),
                 "method": "event.publish",
@@ -688,20 +720,31 @@ async def _run(ws_url: str, token: str, kernel_port: int):
 
 def main():
     # Read boot_info from stdin (only token)
-    token = ""
+    line = sys.stdin.readline().strip()
+    if not line:
+        print(f"{TAG} ERROR: stdin closed")
+        sys.exit(1)
+
     try:
-        line = sys.stdin.readline().strip()
-        if line:
-            boot = json.loads(line)
-            token = boot.get("token", "")
-    except Exception:
-        pass
+        boot = json.loads(line)
+    except json.JSONDecodeError as e:
+        print(f"{TAG} ERROR: Invalid JSON from stdin: {e}")
+        sys.exit(1)
+
+    if "error" in boot:
+        print(f"{TAG} 启动失败: {boot.get('message', 'unknown')}")
+        sys.exit(1)
+
+    token = boot.get("token", "")
+    if not token:
+        print(f"{TAG} ERROR: No token in stdin message")
+        sys.exit(1)
 
     # Read registry_port from environment variable
     kernel_port = int(os.environ.get("KITE_KERNEL_PORT", "0"))
 
-    if not token or not kernel_port:
-        print(f"{TAG} ERROR: Missing token or KITE_KERNEL_PORT")
+    if not kernel_port:
+        print(f"{TAG} ERROR: Missing KITE_KERNEL_PORT")
         sys.exit(1)
 
     ws_url = f"ws://127.0.0.1:{kernel_port}/ws"

package/extensions/event_hub_bench/module.md

@@ -1,27 +1,27 @@
----
-name: event_hub_bench
-display_name: Event Hub Benchmark
-version: "1.0"
-type: tool
-state: manual
-monitor: false
-runtime: python
-entry: entry.py
-events: []
-subscriptions: []
----
-
-# Event Hub Benchmark
-
-事件中心性能基准测试模块。
-
-- 启用后随 Kite 启动自动运行基准测试
-- 通过 Registry 发现 Event Hub，以真实模块身份连接
-- 多线程模拟多个 publisher/subscriber 压测 hub
-- 监控 hub 进程 CPU/内存占用
-- 结果保存到 `KITE_MODULE_DATA/`
-- 测试完成后自动退出
-- 需要 `KITE_DEBUG=1`（多客户端共用一个 token）
-
-启用：将 `state` 改为 `enabled`
-停用：将 `state` 改为 `disabled`
+---
+name: event_hub_bench
+display_name: Event Hub Benchmark
+version: '1.0'
+type: tool
+state: manual
+max_connections: 1
+monitor: true
+runtime: python
+entry: entry.py
+events: []
+subscriptions: []
+---
+# Event Hub Benchmark
+
+事件中心性能基准测试模块。
+
+- 启用后随 Kite 启动自动运行基准测试
+- 通过 Registry 发现 Event Hub，以真实模块身份连接
+- 多线程模拟多个 publisher/subscriber 压测 hub
+- 监控 hub 进程 CPU/内存占用
+- 结果保存到 `KITE_MODULE_DATA/`
+- 测试完成后自动退出
+- 需要 `KITE_DEBUG=1`（多客户端共用一个 token）
+
+启用：将 `state` 改为 `enabled`
+停用：将 `state` 改为 `disabled`

package/extensions/services/audit/README.md

@@ -0,0 +1,134 @@
+# Audit Service
+
+审计服务模块。
+
+## 功能
+
+- 订阅 Kernel 事件，自动记录模块生命周期操作
+- 不可篡改的 append-only 存储
+- 结构化审计事件（操作者、操作、资源、结果）
+- 按时间、操作者、资源类型查询
+
+## 快速开始
+
+### 1. 启动模块
+
+模块会被 Launcher 自动启动（如果 `state: enabled`）。
+
+### 2. 访问 API
+
+```bash
+# 查看 API 文档
+http://127.0.0.1:18770/docs
+
+# 查询审计事件
+curl "http://127.0.0.1:18770/api/audit/events?limit=10"
+
+# 审计统计
+curl "http://127.0.0.1:18770/api/audit/stats"
+```
+
+## API 端点
+
+### 审计 API
+
+- `GET /api/audit/events` — 查询审计事件
+- `GET /api/audit/timeline` — 时间线视图（Phase 2）
+- `GET /api/audit/actors` — 按操作者分组（Phase 2）
+- `GET /api/audit/stats` — 审计统计信息
+
+## 注意
+
+技术日志查询功能已移至独立的 **Logs 模块**（端口 18771）。
+- `GET /api/audit/stats` — 审计统计信息
+
+### 日志 API
+
+- `GET /api/logs/modules` — 列出所有模块及日志统计
+- `GET /api/logs/{module}/list` — 列出模块的日志文件
+- `GET /api/logs/{module}/read` — 读取日志内容
+- `GET /api/logs/{module}/crashes` — 读取崩溃日志
+- `GET /api/logs/search` — 全局搜索
+
+## 存储结构
+
+```
+{KITE_INSTANCE_DIR}/audit/
+├── events/                     # 审计事件
+│   └── 2026-03/
+│       └── 2026-03-09.jsonl    # 每日一个文件
+└── metadata.json               # 审计配置（未来）
+```
+
+## 订阅的事件
+
+- `module.started` — 模块启动
+- `module.stopped` — 模块停止
+- `module.crashed` — 模块崩溃
+- `module.registered` — 模块注册
+- `module.unregistered` — 模块注销
+- `module.offline` — 模块离线
+- `registry.updated` — 注册表更新
+
+## 开发计划
+
+### Phase 1 — 基础框架 ✅
+- [x] 模块骨架
+- [x] 事件收集器
+- [x] Append-only 存储
+- [x] 日志查询 API
+- [x] 基础审计查询 API
+
+### Phase 2 — 完整性保护
+- [ ] 每日日志封存 + SHA256 校验
+- [ ] 完整性验证 API
+- [ ] 自动清理过期日志
+- [ ] 与 backup 模块集成
+
+### Phase 3 — 高级功能
+- [ ] SQLite 索引加速查询
+- [ ] 审计报告导出（CSV/JSON/PDF）
+- [ ] 可视化时间线
+- [ ] 告警规则（异常行为检测）
+
+## 依赖
+
+- Python 3.10+
+- FastAPI
+- websockets
+- PyYAML
+
+## 配置
+
+在 `module.md` 中配置：
+
+```yaml
+name: audit
+preferred_port: 18770
+advertise_ip: 127.0.0.1
+state: enabled
+graceful_shutdown: true
+```
+
+## 故障排查
+
+### 查看日志
+
+```bash
+# 查看最新日志
+cat C:/Users/agentcp/.kite/workspace/Kite/audit/log/latest.log
+
+# 查看崩溃日志
+cat C:/Users/agentcp/.kite/workspace/Kite/audit/log/crashes.jsonl
+```
+
+### 常见问题
+
+**Q: 审计事件没有记录？**
+A: 检查模块是否成功连接到 Kernel，查看日志中是否有 "Connected to Kernel" 消息。
+
+**Q: 日志查询返回空？**
+A: 确认 `KITE_INSTANCE_DIR` 环境变量已设置，且目标模块的日志目录存在。
+
+**Q: API 返回 500 错误？**
+A: 查看 audit 模块的日志，检查是否有 Python 异常。

package/extensions/services/audit/collector.py

@@ -0,0 +1,73 @@
+"""
+Audit event collector.
+Subscribes to Kernel events and converts them to audit events.
+"""
+
+import asyncio
+from typing import Callable
+
+from schemas.audit_event import AuditEvent
+
+
+class AuditCollector:
+    """审计事件收集器"""
+
+    # 需要审计的事件类型
+    AUDIT_EVENTS = [
+        "module.started",
+        "module.stopped",
+        "module.crashed",
+        "module.registered",
+        "module.unregistered",
+        "module.offline",
+        "module.ready",
+        "module.degraded",
+        "module.recovered",
+        "registry.updated",
+        "watchdog.module.restarted",
+        "watchdog.module.resource_warning",
+        "watchdog.module.degraded_timeout",
+    ]
+
+    def __init__(self, on_event: Callable[[AuditEvent], None]):
+        """
+        Args:
+            on_event: 收到审计事件时的回调函数
+        """
+        self.on_event = on_event
+        self._buffer = []
+        self._buffer_size = 1000
+        self._flush_interval = 5.0
+        self._flush_task: asyncio.Task | None = None
+
+    def start(self):
+        """启动收集器（启动定期刷新任务）"""
+        if self._flush_task is None:
+            self._flush_task = asyncio.create_task(self._flush_loop())
+
+    def stop(self):
+        """停止收集器"""
+        if self._flush_task:
+            self._flush_task.cancel()
+            self._flush_task = None
+
+    async def handle_kernel_event(self, event_type: str, event_data: dict, source: str):
+        """处理 Kernel 事件"""
+        # 只处理需要审计的事件
+        if not any(event_type.startswith(prefix) for prefix in self.AUDIT_EVENTS):
+            return
+
+        # 转换为审计事件
+        audit_event = AuditEvent.from_kernel_event(event_type, event_data, source)
+
+        # 立即写入（Phase 1 简化实现，不使用缓冲）
+        self.on_event(audit_event)
+
+    async def _flush_loop(self):
+        """定期刷新缓冲区（Phase 2 实现）"""
+        while True:
+            try:
+                await asyncio.sleep(self._flush_interval)
+                # TODO: 实现批量刷新
+            except asyncio.CancelledError:
+                break