@agentunion/kite 1.3.1 → 1.3.2

package/kernel/server.py

@@ -64,6 +64,11 @@ class KernelServer:
         self._launcher_subscribed = False
         self._ready_published = False
 
+        # Debounce timers for disconnected modules (module_id -> asyncio.Task)
+        self._debounce_tasks: dict[str, asyncio.Task] = {}
+        # Launcher loss timer (35s after launcher offline)
+        self._launcher_loss_task: asyncio.Task | None = None
+
         # Build FastAPI app
         self.app = self._create_app()
 
@@ -110,13 +115,27 @@ class KernelServer:
 
             await ws.accept()
 
+            # 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()
+                print(f"[kernel] {module_id} reconnected within debounce window")
+
             # Register connection in both EventHub and shared connections table
             server.event_hub.add_connection(module_id, ws)
             server.connections[module_id] = ws
 
+            # Set connected status in registry (if module exists)
+            server.registry.set_connected(module_id)
+
             # Track Launcher connection
             if module_id == "launcher":
                 server._launcher_connected = True
+                # Cancel launcher loss timer if reconnecting
+                if server._launcher_loss_task:
+                    server._launcher_loss_task.cancel()
+                    server._launcher_loss_task = None
+                    print(f"[kernel] launcher reconnected, cancelled loss timer")
                 print(f"[kernel] launcher connected")
 
             # Renew heartbeat on connect
@@ -163,12 +182,19 @@ class KernelServer:
                 if "not connected" not in err and "closed" not in err:
                     print(f"[kernel] WebSocket error for {module_id}: {e}")
             finally:
-                # Cleanup
+                # Cleanup connection but DON'T immediately set offline — debounce
                 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})
+
+                # Cancel existing debounce for this module (if reconnecting fast)
+                old_task = server._debounce_tasks.pop(module_id, None)
+                if old_task:
+                    old_task.cancel()
+
+                # Start 5s debounce timer
+                server._debounce_tasks[module_id] = asyncio.create_task(
+                    server._debounce_offline(module_id)
+                )
 
         # ── HTTP endpoints (debug only) ──
 
@@ -180,7 +206,7 @@ class KernelServer:
                 "module_count": len(server.registry.modules),
                 "online_count": sum(
                     1 for m in server.registry.modules.values()
-                    if m.get("status") == "online"
+                    if m.get("status") in ("registered", "ready")
                 ),
                 "event_stats": eh_health.get("details", {}),
             }
@@ -227,6 +253,50 @@ class KernelServer:
             except Exception as e:
                 print(f"[kernel] Dedup cleanup error: {e}")
 
+    # ── Debounce & Launcher loss ──
+
+    async def _debounce_offline(self, module_id: str):
+        """Wait 5s after WS disconnect. If module doesn't reconnect, mark offline."""
+        try:
+            await asyncio.sleep(5)
+        except asyncio.CancelledError:
+            return  # Module reconnected within 5s — cancelled by ws_endpoint
+
+        # 5s elapsed, module did not reconnect — mark offline
+        self._debounce_tasks.pop(module_id, None)
+        self.registry.set_offline(module_id)
+        self.event_hub.publish_internal("module.offline", {"module_id": module_id})
+        print(f"[kernel] {module_id} offline (5s debounce expired)")
+
+        # If launcher went offline, start 35s launcher loss timer
+        if module_id == "launcher":
+            self._launcher_connected = False
+            if not self._launcher_loss_task:
+                self._launcher_loss_task = asyncio.create_task(
+                    self._launcher_loss_timeout()
+                )
+
+    async def _launcher_loss_timeout(self):
+        """35s after launcher goes offline (post-debounce). Trigger graceful shutdown."""
+        try:
+            await asyncio.sleep(30)  # 5s debounce already elapsed, total = 35s
+        except asyncio.CancelledError:
+            return  # Launcher reconnected
+
+        print("[kernel] Launcher lost for 35s, triggering graceful shutdown")
+        self._launcher_loss_task = None
+
+        # Publish module.shutdown with reason launcher_lost to all modules
+        self.event_hub.publish_internal("module.shutdown", {
+            "reason": "launcher_lost",
+        })
+
+        # Wait for modules to clean up (up to 10s)
+        await asyncio.sleep(10)
+
+        # Shutdown Kernel itself
+        await self.shutdown()
+
     # ── Self-registration ──
 
     def self_register(self):

package/launcher/count_lines.py

@@ -185,6 +185,40 @@ def show_history(record_file: Path, limit: int = 10):
 
     print("=" * 80 + "\n")
 
+    # 计算每日新增
+    daily_stats = {}
+    for record in records:
+        date = record["timestamp"][:10]  # YYYY-MM-DD
+        total = record["stats"]["total"]
+        if date not in daily_stats:
+            daily_stats[date] = {"first": total, "last": total}
+        else:
+            daily_stats[date]["last"] = total
+
+    # 计算每日增量
+    daily_changes = []
+    for date in sorted(daily_stats.keys()):
+        day_data = daily_stats[date]
+        daily_change = day_data["last"] - day_data["first"]
+        if daily_change != 0:  # 只显示有变化的日期
+            daily_changes.append((date, daily_change))
+
+    if daily_changes:
+        print("=" * 80)
+        print("每日新增代码行数")
+        print("=" * 80)
+        print(f"{'日期':<15} {'新增行数':>15}")
+        print("-" * 80)
+        for date, change in daily_changes[-10:]:  # 最近 10 天
+            if change > 0:
+                change_str = f"{GREEN}+{change:,}{RESET}"
+            elif change < 0:
+                change_str = f"{RED}{change:,}{RESET}"
+            else:
+                change_str = "0"
+            print(f"{date:<15} {change_str:>15}")
+        print("=" * 80 + "\n")
+
 
 def run_stats():
     """Run code stats from main.py entry point (simplified output)."""

package/launcher/entry.py

@@ -303,6 +303,21 @@ class Launcher:
                     ch = msvcrt.getch()
                     if ch == b'\x1b':  # ESC - force exit immediately
                         print("[launcher] ESC 强制退出")
+                        # Send module.exiting before exit (best effort)
+                        try:
+                            if self._ws and self._loop:
+                                import concurrent.futures
+                                fut = asyncio.run_coroutine_threadsafe(
+                                    self._publish_event("module.exiting", {
+                                        "module_id": "launcher",
+                                        "reason": "ESC exit",
+                                        "action": "none",
+                                    }),
+                                    self._loop,
+                                )
+                                fut.result(timeout=1)  # Wait up to 1s
+                        except Exception:
+                            pass
                         os._exit(0)
                     elif ch in (b'q', b'Q'):  # q/Q - graceful shutdown
                         self._request_shutdown("收到退出请求，正在关闭...")
@@ -316,7 +331,7 @@ class Launcher:
         """Full 2-phase startup sequence, then monitor loop."""
         self._loop = asyncio.get_running_loop()
         self._ws_connected = asyncio.Event()  # Create event in async context
-        t_start = time.monotonic()
+        self._t_start = time.monotonic()  # Store for launcher ready_time calculation
         self._start_unix = time.time()
         phase_times = {}
         G = "\033[32m"
@@ -396,7 +411,7 @@ class Launcher:
             )
 
             # ── Startup report ──
-            total_time = time.monotonic() - t_start
+            total_time = time.monotonic() - self._t_start
             await self._print_startup_report(total_time, phase_times,
                                              global_instances=global_instances,
                                              cleaned_stats=cleaned_stats)
@@ -557,17 +572,36 @@ class Launcher:
     # ── Kernel WebSocket connection (JSON-RPC 2.0) ──
 
     async def _ws_loop(self):
-        """Connect to Kernel, reconnect on failure."""
+        """Connect to Kernel, reconnect on failure with exponential backoff."""
+        retry_delay = 0.3
+        max_delay = 5.0
+        max_retries = 10
+        attempt = 0
         while not self._thread_shutdown.is_set():
             try:
                 await self._ws_connect()
+                retry_delay = 0.3  # Reset on successful connection
+                attempt = 0
             except asyncio.CancelledError:
                 return
             except Exception as e:
                 if not self._system_shutting_down:
-                    print(f"[launcher] Kernel 连接错误: {e}")
+                    attempt += 1
+                    # Check for 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"[launcher] Kernel 认证失败 (code {code})，退出")
+                            sys.exit(1)
+                    if attempt >= max_retries:
+                        print(f"[launcher] Kernel 重连失败 {max_retries} 次，退出")
+                        sys.exit(1)
+                    print(f"[launcher] Kernel 连接错误: {e}, {retry_delay:.1f}s 后重试 ({attempt}/{max_retries})")
             self._ws = None
-            await asyncio.sleep(5)
+            if self._thread_shutdown.is_set():
+                return
+            await asyncio.sleep(retry_delay)
+            retry_delay = min(retry_delay * 2, max_delay)
 
     async def _ws_connect(self):
         """Single WebSocket session with JSON-RPC 2.0 protocol."""
@@ -607,6 +641,12 @@ class Launcher:
                 })
                 print("[launcher] 已注册到 Kernel")
 
+                # Publish module.ready for Launcher itself (every reconnect)
+                await self._publish_event("module.ready", {
+                    "module_id": "launcher",
+                    "graceful_shutdown": True,
+                })
+
                 # Signal that connection is ready (after subscription and registration)
                 if self._ws_connected:
                     self._ws_connected.set()
@@ -899,9 +939,15 @@ class Launcher:
     async def _wait_event(self, event_type: str, module_id: str, timeout: float) -> dict | None:
         """Wait for a specific event from a module. Returns data dict or None on timeout."""
         key = f"{event_type}:{module_id}"
-        evt = asyncio.Event()
-        data = {}
-        self._event_waiters[key] = (evt, data)
+        # Reuse existing waiter if one was pre-registered (e.g. in _ws_connect)
+        # This prevents a race where the event arrives before this method is called
+        existing = self._event_waiters.get(key)
+        if existing:
+            evt, data = existing
+        else:
+            evt = asyncio.Event()
+            data = {}
+            self._event_waiters[key] = (evt, data)
         try:
             await asyncio.wait_for(evt.wait(), timeout=timeout)
             return data
@@ -981,12 +1027,21 @@ class Launcher:
 
     async def _graceful_shutdown_all(self):
         """Shut down all modules. Order:
-        1. Send shutdown to graceful modules (excl. Kernel) — let them start cleanup
-        2. Terminate non-graceful modules (fast, runs during graceful cleanup)
-        3. Wait for graceful modules to exit (process monitoring)
-        4. Shut down Kernel last (keeps event routing alive throughout)
+        1. Send module.exiting for Launcher itself (so Watchdog knows it's intentional)
+        2. Send shutdown to graceful modules (excl. Kernel) — let them start cleanup
+        3. Terminate non-graceful modules (fast, runs during graceful cleanup)
+        4. Wait for graceful modules to exit (process monitoring)
+        5. Shut down Kernel last (keeps event routing alive throughout)
         """
         self._system_shutting_down = True
+
+        # Send module.exiting for Launcher before anything else
+        await self._publish_event("module.exiting", {
+            "module_id": "launcher",
+            "reason": "system_shutdown",
+            "action": "none",
+        })
+
         running = [n for n in self.modules if self.process_manager.is_running(n)]
         # Also check core modules
         for cn in CORE_MODULE_NAMES:
@@ -1457,6 +1512,22 @@ class Launcher:
         running = []
         exited = []
         stopped = []
+
+        # Add Launcher itself to running list
+        from types import SimpleNamespace
+        launcher_info = SimpleNamespace(
+            display_name="Launcher",
+            type="infrastructure",
+        )
+        launcher_rec = SimpleNamespace(
+            pid=os.getpid(),
+            started_at=self._start_unix,
+        )
+        running.append(("launcher", launcher_info, launcher_rec))
+        # Launcher is ready immediately (ready_time = 0)
+        if "launcher" not in self._ready_times:
+            self._ready_times["launcher"] = 0.0
+
         for name, info in self.modules.items():
             rec = self.process_manager.get_record(name)
             is_running = self.process_manager.is_running(name)
@@ -1527,9 +1598,16 @@ class Launcher:
             label = info.display_name or name
             ready_t = self._ready_times.get(name)
             time_str = f"{ready_t:.2f}s" if ready_t is not None else "—"
+
+            # Calculate elapsed from start
             if ready_t is not None and hasattr(self, '_start_unix'):
-                elapsed_from_start = (rec.started_at + ready_t) - self._start_unix
-                es_str = f"{elapsed_from_start:.2f}s"
+                if name == "launcher":
+                    # Launcher: ready_t is already relative to _start_unix
+                    es_str = f"{ready_t:.2f}s"
+                else:
+                    # Other modules: rec.started_at is unix timestamp
+                    elapsed_from_start = (rec.started_at + ready_t) - self._start_unix
+                    es_str = f"{elapsed_from_start:.2f}s"
             else:
                 es_str = "—"
 

package/launcher/process_manager.py

@@ -327,8 +327,19 @@ class ProcessManager:
             return 0
 
         # Dead launcher (or old format) — clean up its child processes
+        # Sort: watchdog first, kernel last, others in middle (prevents cascading issues)
+        def _cleanup_sort_key(entry):
+            name = entry.get("name", "")
+            if name == "watchdog":
+                return (0, name)
+            if name == "kernel":
+                return (2, name)
+            return (1, name)
+
+        records_sorted = sorted(records, key=_cleanup_sort_key)
+
         killed = 0
-        for entry in records:
+        for entry in records_sorted:
             pid = entry.get("pid", 0)
             cmd = entry.get("cmd", [])
             name = entry.get("name", "?")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentunion/kite",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Kite framework launcher — start Kite from anywhere",
   "bin": {
     "kite": "./cli.js"