@agentunion/kite 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -1,4 +1,90 @@
-# v1.3.0
+# v1.3.2
+
+**发布日期**：2026-03-04
+**上一版本**：v1.3.1
+**版本级别**：patch
+
+---
+
+## 核心变更
+
+本次发布主要包含功能增强和稳定性改进。新增 Web 模块管理 API，支持通过 HTTP 接口扫描、查看和编辑模块元数据与配置。Kernel 模块增加断线重连防抖机制（5 秒窗口），避免短暂网络波动导致的模块状态误判。多个扩展模块和前端界面进行了优化更新。
+
+---
+
+## 变更统计
+
+| 类型 | 数量 | 说明 |
+|------|------|------|
+| 新增 | 1 | `routes_modules.py` (249 行) |
+| 修改 | 18 | kernel、launcher、扩展模块、web 前端 |
+
+---
+
+## 关键变更
+
+### 新增功能
+
+**`extensions/services/web/routes/routes_modules.py`** (249 行)
+- 模块管理 API：扫描项目中的所有模块
+- 元数据查看与编辑（`module.md` 前置元数据）
+- 配置查看与编辑（`config.yaml`）
+- 只读字段保护（`name`, `type`, `runtime`, `entry`）
+
+### 核心改进
+
+**`kernel/server.py`** — 断线重连防抖
+```diff
++ # Debounce timers for disconnected modules (module_id -> asyncio.Task)
++ self._debounce_tasks: dict[str, asyncio.Task] = {}
++ # Cancel debounce timer if module is reconnecting within 5s window
++ old_debounce = server._debounce_tasks.pop(module_id, None)
++ if old_debounce:
++     old_debounce.cancel()
+```
+- 5 秒防抖窗口，避免短暂断线误判
+- Launcher 离线 35 秒后触发全局重启
+
+**`kernel/registry_store.py`** — 连接状态管理
+- 新增 `set_connected()` / `set_disconnected()` 方法
+- 模块注册表支持实时连接状态跟踪
+
+**`launcher/entry.py`** — 进程管理优化
+- 改进模块启动和停止逻辑
+- 优化日志输出和错误处理
+
+### 前端更新
+
+**Web UI** (`static/index.html`, `static/js/app.js`, `static/css/style.css`)
+- 界面样式优化
+- 交互逻辑改进
+- 新增模块管理相关 UI 组件
+
+### 扩展模块适配
+
+更新以下模块以适配 Kernel 连接状态管理：
+- `extensions/agents/assistant/server.py`
+- `extensions/channels/acp_channel/server.py`
+- `extensions/services/backup/entry.py`
+- `extensions/services/model_service/entry.py`
+- `extensions/services/watchdog/entry.py`
+- `extensions/services/watchdog/monitor.py`
+
+---
+
+## 包信息
+
+- **文件数**：88（与 v1.3.1 相同）
+- **打包大小**：~208 kB
+
+---
+
+## 稳定性改进
+
+- ✅ **断线重连防抖** — 避免短暂网络波动导致模块误判为离线
+- ✅ **连接状态跟踪** — Registry 实时记录模块连接状态
+- ✅ **Launcher 保护** — 35 秒容错窗口，避免误触发全局重启
+# v1.3.1
 
 **发布日期**：2026-03-04
 **上一版本**：v1.2.0

package/extensions/agents/assistant/server.py

@@ -21,7 +21,6 @@ class AssistantServer:
         self._ws_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
-        self._ready_sent = False
         self._shutting_down = False
         self._start_time = time.time()
 
@@ -42,15 +41,29 @@ class AssistantServer:
 
     async def _ws_loop(self):
         """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
-        retry_delay = 0.5
-        max_delay = 30
+        retry_delay = 0.3
+        max_delay = 5.0
+        max_retries = 10
+        attempt = 0
         while not self._shutting_down:
             try:
                 await self._ws_connect()
+                retry_delay = 0.3
+                attempt = 0
             except asyncio.CancelledError:
                 return
             except Exception as e:
-                print(f"[assistant] Kernel connection error: {e}, retrying in {retry_delay:.1f}s")
+                attempt += 1
+                # Auth failure — don't retry
+                if hasattr(e, 'rcvd') and e.rcvd is not None:
+                    code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
+                    if code in (4001, 4003):
+                        print(f"[assistant] Kernel 认证失败 (code {code})，退出")
+                        import sys; sys.exit(1)
+                if attempt >= max_retries:
+                    print(f"[assistant] Kernel 重连失败 {max_retries} 次，退出")
+                    import sys; sys.exit(1)
+                print(f"[assistant] Kernel connection error: {e}, retrying in {retry_delay:.1f}s ({attempt}/{max_retries})")
             self._ws = None
             if self._shutting_down:
                 return
@@ -87,8 +100,8 @@ class AssistantServer:
                 ],
             })
 
-            # Step 3: Publish module.ready (once)
-            if not self._ready_sent:
+            # Step 3: Publish module.ready (every reconnect)
+            if not self._shutting_down:
                 await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
@@ -97,14 +110,10 @@ class AssistantServer:
                         "graceful_shutdown": True,
                     },
                 })
-                self._ready_sent = True
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
                 print(f"[assistant] module.ready published{elapsed_str}")
 
-            # Reset retry delay on successful connection
-            retry_delay = 0.5
-
             # Receive loop
             async for raw in ws:
                 try:
@@ -123,7 +132,9 @@ class AssistantServer:
                         if event_name == "module.shutdown":
                             data = params.get("data", {})
                             target = data.get("module_id", "")
-                            if target == "assistant":
+                            reason = data.get("reason", "")
+                            # Handle both targeted shutdown (module_id == "assistant") and broadcast shutdown (no module_id or launcher_lost)
+                            if target == "assistant" or not target or reason == "launcher_lost":
                                 await self._handle_shutdown(ws)
                                 return
                     elif not has_method and has_id:
@@ -133,10 +144,17 @@ class AssistantServer:
                     print(f"[assistant] 事件处理异常（已忽略）: {e}")
 
     async def _handle_shutdown(self, ws):
-        """Handle module.shutdown: ack → cleanup → ready → exit."""
+        """Handle module.shutdown: exiting → ack → cleanup → ready → exit."""
         print("[assistant] Received module.shutdown")
         self._shutting_down = True
 
+        # Step 0: Send module.exiting
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": "module.exiting",
+            "data": {"module_id": "assistant", "action": "none"},
+        })
+
         # Step 1: Send ack
         await self._rpc_call(ws, "event.publish", {
             "event_id": str(uuid.uuid4()),

package/extensions/channels/acp_channel/server.py

@@ -21,7 +21,6 @@ class AcpChannelServer:
         self._ws_task: asyncio.Task | None = None
         self._test_task: asyncio.Task | None = None
         self._ws: object | None = None
-        self._ready_sent = False
         self._shutting_down = False
         self._start_time = time.time()
 
@@ -42,15 +41,29 @@ class AcpChannelServer:
 
     async def _ws_loop(self):
         """Connect to Kernel, subscribe, register, and listen. Reconnect on failure."""
-        retry_delay = 0.5
-        max_delay = 30
+        retry_delay = 0.3
+        max_delay = 5.0
+        max_retries = 10
+        attempt = 0
         while not self._shutting_down:
             try:
                 await self._ws_connect()
+                retry_delay = 0.3
+                attempt = 0
             except asyncio.CancelledError:
                 return
             except Exception as e:
-                print(f"[acp_channel] Kernel connection error: {e}, retrying in {retry_delay:.1f}s")
+                attempt += 1
+                # Auth failure — don't retry
+                if hasattr(e, 'rcvd') and e.rcvd is not None:
+                    code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
+                    if code in (4001, 4003):
+                        print(f"[acp_channel] Kernel 认证失败 (code {code})，退出")
+                        import sys; sys.exit(1)
+                if attempt >= max_retries:
+                    print(f"[acp_channel] Kernel 重连失败 {max_retries} 次，退出")
+                    import sys; sys.exit(1)
+                print(f"[acp_channel] Kernel connection error: {e}, retrying in {retry_delay:.1f}s ({attempt}/{max_retries})")
             self._ws = None
             if self._shutting_down:
                 return
@@ -87,8 +100,8 @@ class AcpChannelServer:
                 ],
             })
 
-            # Step 3: Publish module.ready (once)
-            if not self._ready_sent:
+            # Step 3: Publish module.ready (every reconnect)
+            if not self._shutting_down:
                 await self._rpc_call(ws, "event.publish", {
                     "event_id": str(uuid.uuid4()),
                     "event": "module.ready",
@@ -97,14 +110,10 @@ class AcpChannelServer:
                         "graceful_shutdown": True,
                     },
                 })
-                self._ready_sent = True
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
                 print(f"[acp_channel] module.ready published{elapsed_str}")
 
-            # Reset retry delay on successful connection
-            retry_delay = 0.5
-
             # Receive loop
             async for raw in ws:
                 try:
@@ -123,7 +132,9 @@ class AcpChannelServer:
                         if event_name == "module.shutdown":
                             data = params.get("data", {})
                             target = data.get("module_id", "")
-                            if target == "acp_channel":
+                            reason = data.get("reason", "")
+                            # Handle both targeted shutdown (module_id == "acp_channel") and broadcast shutdown (no module_id or launcher_lost)
+                            if target == "acp_channel" or not target or reason == "launcher_lost":
                                 await self._handle_shutdown(ws)
                                 return
                     elif not has_method and has_id:
@@ -133,10 +144,17 @@ class AcpChannelServer:
                     print(f"[acp_channel] 事件处理异常（已忽略）: {e}")
 
     async def _handle_shutdown(self, ws):
-        """Handle module.shutdown: ack → cleanup → ready → exit."""
+        """Handle module.shutdown: exiting → ack → cleanup → ready → exit."""
         print("[acp_channel] Received module.shutdown")
         self._shutting_down = True
 
+        # Step 0: Send module.exiting
+        await self._rpc_call(ws, "event.publish", {
+            "event_id": str(uuid.uuid4()),
+            "event": "module.exiting",
+            "data": {"module_id": "acp_channel", "action": "none"},
+        })
+
         # Step 1: Send ack
         await self._rpc_call(ws, "event.publish", {
             "event_id": str(uuid.uuid4()),

package/extensions/services/backup/entry.py

@@ -263,10 +263,19 @@ 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
+
+
+def _is_auth_failure(e: Exception) -> bool:
+    """Check if a WebSocket exception indicates authentication failure."""
+    if hasattr(e, 'rcvd') and e.rcvd is not None:
+        code = e.rcvd.code if hasattr(e.rcvd, 'code') else 0
+        return code in (4001, 4003)
+    return False
 
 
 async def main():
-    global _ws_global
+    global _ws_global, _shutting_down
     # Initialize log file paths
     global _log_dir, _log_latest_path, _crash_log_path
     module_data = os.environ.get("KITE_MODULE_DATA")
@@ -318,41 +327,84 @@ async def main():
 
     print(f"[backup] Token received ({len(token)} chars), kernel port: {kernel_port} ({_fmt_elapsed(_t0)})")
 
-    # Connect to Kernel WebSocket
+    # Start reconnect loop
+    await _ws_loop(token, kernel_port, _t0)
+
+
+async def _ws_loop(token: str, kernel_port: int, _t0: float):
+    """Connect to Kernel with exponential backoff reconnection."""
+    global _shutting_down
+    retry_delay = 0.3
+    max_delay = 5.0
+    max_retries = 10
+    attempt = 0
+    while not _shutting_down:
+        try:
+            await _ws_connect(token, kernel_port, _t0)
+            retry_delay = 0.3
+            attempt = 0
+        except asyncio.CancelledError:
+            return
+        except Exception as e:
+            attempt += 1
+            if _is_auth_failure(e):
+                print(f"[backup] Kernel 认证失败，退出")
+                sys.exit(1)
+            if attempt >= max_retries:
+                print(f"[backup] 重连失败 {max_retries} 次，退出")
+                sys.exit(1)
+            _write_crash(type(e), e, e.__traceback__, severity="error", handled=True)
+            print(f"[backup] 连接错误: {e}, {retry_delay:.1f}s 后重试 ({attempt}/{max_retries})")
+        _ws_global_clear()
+        if _shutting_down:
+            return
+        await asyncio.sleep(retry_delay)
+        retry_delay = min(retry_delay * 2, max_delay)
+
+
+def _ws_global_clear():
+    global _ws_global
+    _ws_global = None
+
+
+async def _ws_connect(token: str, kernel_port: int, _t0: float):
+    """Single WebSocket session: connect → subscribe → register → ready → receive loop."""
+    global _ws_global
+
     ws_url = f"ws://127.0.0.1:{kernel_port}/ws?token={token}&id=backup"
     print(f"[backup] Connecting to Kernel: {ws_url}")
 
-    try:
-        async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
-            _ws_global = ws
-            print(f"[backup] Connected to Kernel ({_fmt_elapsed(_t0)})")
-
-            # Subscribe to events
-            await _rpc_call(ws, "event.subscribe", {
-                "events": [
-                    "module.started",
-                    "module.stopped",
-                    "module.shutdown",
-                ],
-            })
-            print(f"[backup] Subscribed to events ({_fmt_elapsed(_t0)})")
-
-            # Register to Kernel Registry via RPC
-            await _rpc_call(ws, "registry.register", {
-                "module_id": "backup",
-                "module_type": "service",
-                "events_publish": {
-                    "backup.test": {"description": "Test event from backup module"},
-                },
-                "events_subscribe": [
-                    "module.started",
-                    "module.stopped",
-                    "module.shutdown",
-                ],
-            })
-            print(f"[backup] Registered to Kernel ({_fmt_elapsed(_t0)})")
+    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
+        _ws_global = ws
+        print(f"[backup] Connected to Kernel ({_fmt_elapsed(_t0)})")
+
+        # Subscribe to events
+        await _rpc_call(ws, "event.subscribe", {
+            "events": [
+                "module.started",
+                "module.stopped",
+                "module.shutdown",
+            ],
+        })
+        print(f"[backup] Subscribed to events ({_fmt_elapsed(_t0)})")
+
+        # Register to Kernel Registry via RPC
+        await _rpc_call(ws, "registry.register", {
+            "module_id": "backup",
+            "module_type": "service",
+            "events_publish": {
+                "backup.test": {"description": "Test event from backup module"},
+            },
+            "events_subscribe": [
+                "module.started",
+                "module.stopped",
+                "module.shutdown",
+            ],
+        })
+        print(f"[backup] Registered to Kernel ({_fmt_elapsed(_t0)})")
 
-            # Publish module.ready
+        # Publish module.ready (every reconnect)
+        if not _shutting_down:
             await _rpc_call(ws, "event.publish", {
                 "event_id": str(uuid.uuid4()),
                 "event": "module.ready",
@@ -363,34 +415,29 @@ async def main():
             })
             print(f"[backup] module.ready published ({_fmt_elapsed(_t0)})")
 
-            # Start test event loop in background
-            test_task = asyncio.create_task(_test_event_loop(ws))
-
-            # Message loop: handle incoming RPC + events
-            async for raw in ws:
-                try:
-                    msg = json.loads(raw)
-                except (json.JSONDecodeError, TypeError):
-                    continue
-
-                try:
-                    has_method = "method" in msg
-                    has_id = "id" in msg
-
-                    if has_method and not has_id:
-                        # Event Notification
-                        await _handle_event_notification(msg)
-                    elif has_method and has_id:
-                        # Incoming RPC request
-                        await _handle_rpc_request(ws, msg)
-                    # Ignore RPC responses (we don't await them in this simple impl)
-                except Exception as e:
-                    print(f"[backup] 消息处理异常（已忽略）: {e}")
-
-    except Exception as e:
-        _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
-        _print_crash_summary(type(e), e.__traceback__)
-        sys.exit(1)
+        # Start test event loop in background
+        test_task = asyncio.create_task(_test_event_loop(ws))
+
+        # Message loop: handle incoming RPC + events
+        async for raw in ws:
+            try:
+                msg = json.loads(raw)
+            except (json.JSONDecodeError, TypeError):
+                continue
+
+            try:
+                has_method = "method" in msg
+                has_id = "id" in msg
+
+                if has_method and not has_id:
+                    # Event Notification
+                    await _handle_event_notification(msg)
+                elif has_method and has_id:
+                    # Incoming RPC request
+                    await _handle_rpc_request(ws, msg)
+                # Ignore RPC responses (we don't await them in this simple impl)
+            except Exception as e:
+                print(f"[backup] 消息处理异常（已忽略）: {e}")
 
 
 async def _rpc_call(ws, method: str, params: dict = None):
@@ -416,10 +463,14 @@ async def _handle_event_notification(msg: dict):
     event_type = params.get("event", "")
     data = params.get("data", {})
 
-    # Special handling for module.shutdown targeting backup
-    if event_type == "module.shutdown" and data.get("module_id") == "backup":
-        await _handle_shutdown()
-        return
+    # Special handling for module.shutdown
+    if event_type == "module.shutdown":
+        target = data.get("module_id", "")
+        reason = data.get("reason", "")
+        # Handle both targeted shutdown (module_id == "backup") and broadcast shutdown (no module_id or launcher_lost)
+        if target == "backup" or not target or reason == "launcher_lost":
+            await _handle_shutdown()
+            return
 
     # Log other events
     print(f"[backup] Event received: {event_type}")
@@ -472,8 +523,15 @@ async def _rpc_status() -> dict:
 
 
 async def _handle_shutdown():
-    """Handle module.shutdown event — ack, cleanup, ready, exit."""
+    """Handle module.shutdown event — exiting → ack → cleanup → ready → exit."""
+    global _shutting_down
     print("[backup] Received shutdown request")
+    _shutting_down = True
+    # Step 0: Send module.exiting
+    await _publish_event(_ws_global, {
+        "event": "module.exiting",
+        "data": {"module_id": "backup", "action": "none"},
+    })
     # Step 1: Send ack
     await _publish_event(_ws_global, {
         "event": "module.shutdown.ack",