@agentunion/kite 1.4.0 → 1.5.0

package/extensions/services/proxy/server.py

@@ -0,0 +1,271 @@
+"""
+server.py - 精简版 FastAPI 服务器
+
+仅提供4个代理路由 + 健康检查：
+- /claude-proxy/{path}  - Claude代理（仅 v1/messages 路径且 model 包含 "claude"）
+- /codex-proxy/{path}   - Codex代理（不做 model 过滤）
+- /gemini-proxy/{path}  - Gemini代理（不做 model 过滤）
+- /openclaw-proxy/{path} - OpenClaw代理（OpenAI兼容接口）
+- /health               - 健康检查
+"""
+
+import asyncio
+import json
+import logging
+import threading
+import time
+import uuid
+
+import uvicorn
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, Response
+
+
+# ==================== 并发管理器 ====================
+
+class ConcurrencyLimitManager:
+    """管理代理接口的总并发数，带自动清理超时请求"""
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super().__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._active_requests = {}
+        self._count_lock = threading.Lock()
+        self._timeout_seconds = 300
+        self._limit = 5
+        print("[ConcurrencyLimitManager] initialized")
+
+    def acquire(self) -> tuple:
+        with self._count_lock:
+            self._cleanup_timeout_requests()
+            request_id = f"req_{int(time.time() * 1000)}_{id(threading.current_thread())}"
+            self._active_requests[request_id] = time.time()
+            return True, "", request_id
+
+    def release(self, request_id: str = None):
+        with self._count_lock:
+            if request_id and request_id in self._active_requests:
+                del self._active_requests[request_id]
+            elif not request_id and self._active_requests:
+                oldest_id = min(self._active_requests, key=self._active_requests.get)
+                del self._active_requests[oldest_id]
+
+    def _cleanup_timeout_requests(self):
+        current_time = time.time()
+        timeout_ids = [
+            rid for rid, t in self._active_requests.items()
+            if current_time - t > self._timeout_seconds
+        ]
+        for rid in timeout_ids:
+            del self._active_requests[rid]
+
+    def get_current_count(self) -> int:
+        with self._count_lock:
+            return len(self._active_requests)
+
+
+concurrency_manager = ConcurrencyLimitManager()
+
+
+# ==================== FastAPI 应用 ====================
+
+app = FastAPI(title="Evol Sample Backend", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ==================== 健康检查 ====================
+
+@app.get("/health")
+async def health_check():
+    from evol.server.claude_proxy_async import get_current_agent_id
+    agent_id = get_current_agent_id()
+    return {
+        "status": "ok",
+        "agent_id": agent_id.id if agent_id else None,
+        "is_online": agent_id.is_online_success if agent_id else False,
+        "active_requests": concurrency_manager.get_current_count()
+    }
+
+
+# ==================== Claude Proxy 路由 ====================
+
+@app.api_route("/claude-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def claude_proxy_route(request: Request, full_path: str):
+    """Claude代理路由 - 仅放行 v1/messages 路径且 model 包含 'claude'"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    if "v1/messages" not in full_path:
+        concurrency_manager.release(request_id)
+        raise HTTPException(status_code=200, detail="OK")
+
+    try:
+        request_body = await request.body()
+        bodyjson = await asyncio.to_thread(json.loads, request_body.decode('utf-8'))
+        model = bodyjson.get('model', '')
+        if "claude" not in model:
+            raise HTTPException(status_code=400, detail="Unsupported model")
+
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("claude-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== Codex Proxy 路由 ====================
+
+@app.api_route("/codex-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def codex_proxy_route(request: Request, full_path: str):
+    """Codex代理路由 - 不做 model 过滤"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    try:
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("codex-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== Gemini Proxy 路由 ====================
+
+@app.api_route("/gemini-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def gemini_proxy_route(request: Request, full_path: str):
+    """Gemini代理路由 - 不做 model 过滤"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        return Response(content=error_msg.encode("utf-8"), status_code=429)
+
+    try:
+        from evol.server.claude_proxy_async import proxy_claude_request
+        response = await proxy_claude_request(request)
+        return response
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("gemini-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        if isinstance(e, HTTPException):
+            return Response(content=str(e.detail).encode("utf-8"), status_code=e.status_code)
+        return Response(content=str(e).encode("utf-8"), status_code=503)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== OpenClaw Proxy 路由 ====================
+
+@app.api_route("/openclaw-proxy/{full_path:path}",
+               methods=["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+async def openclaw_proxy_route(request: Request, full_path: str):
+    """OpenClaw代理路由 - OpenAI兼容接口"""
+    acquired, error_msg, request_id = concurrency_manager.acquire()
+    if not acquired:
+        from evol.server.openclaw_proxy import openai_error_response
+        return openai_error_response(error_msg, error_type="rate_limit_exceeded", status_code=429)
+
+    try:
+        if full_path == "v1/models":
+            from evol.server.openclaw_proxy import get_models_list
+            return JSONResponse(get_models_list())
+        elif full_path == "v1/chat/completions":
+            from evol.server.openclaw_proxy import proxy_openclaw_request
+            response = await proxy_openclaw_request(request)
+            return response
+        else:
+            from evol.server.openclaw_proxy import openai_error_response
+            return openai_error_response(
+                f"Path not found: /{full_path}. Supported: /v1/models, /v1/chat/completions.",
+                error_type="invalid_request_error",
+                status_code=404
+            )
+
+    except asyncio.CancelledError:
+        logging.getLogger("evol_server").warning("openclaw-proxy request cancelled (client disconnected?)")
+        return Response(content=b"Client Closed Request", status_code=499)
+    except Exception as e:
+        from evol.server.openclaw_proxy import openai_error_response
+        return openai_error_response(f"Internal server error: {str(e)}", error_type="api_error", status_code=500)
+    finally:
+        concurrency_manager.release(request_id)
+
+
+# ==================== 启动服务器 ====================
+
+# 全局变量存储实际端口
+_actual_port = None
+
+def get_actual_port():
+    """获取服务器实际使用的端口"""
+    return _actual_port
+
+async def run_server(port: int = 0):
+    """启动 FastAPI 服务器
+
+    Args:
+        port: 端口号，0 表示系统自动分配
+    """
+    global _actual_port
+
+    # 如果端口为 0，先获取一个可用端口
+    if port == 0:
+        import socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.bind(('', 0))
+        port = sock.getsockname()[1]
+        sock.close()
+
+    _actual_port = port
+
+    config = uvicorn.Config(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info",
+        access_log=True,
+    )
+    server = uvicorn.Server(config)
+    server.install_signal_handlers = False  # 禁止 uvicorn 安装信号处理器，防止外部信号导致服务器关闭
+    await server.serve()

package/extensions/services/watchdog/entry.py

@@ -504,7 +504,7 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
     ws_url = f"ws://127.0.0.1:{kernel_port}/ws?token={token}&id=watchdog"
     print(f"[watchdog] Connecting to Kernel: {ws_url}")
 
-    async with websockets.connect(ws_url, open_timeout=5, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
         _ws_global = ws
         print(f"[watchdog] Connected to Kernel ({_fmt_elapsed(_t0)})")
 
@@ -564,12 +564,14 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
 
         # Publish module.ready (every reconnect)
         if not _shutting_down:
+            startup_time = time.monotonic() - _t0
             await _rpc_call(ws, "event.publish", {
                 "event_id": str(uuid.uuid4()),
                 "event": "module.ready",
                 "data": {
                     "module_id": "watchdog",
                     "graceful_shutdown": True,
+                    "startup_time": startup_time,
                 },
             })
             print(f"[watchdog] module.ready published ({_fmt_elapsed(_t0)})")
@@ -578,9 +580,6 @@ async def _ws_connect(token: str, kernel_port: int, _t0: float):
         if _monitor_task is None or _monitor_task.done():
             _monitor_task = asyncio.create_task(_monitor.run())
 
-        # Start heartbeat loop
-        heartbeat_task = asyncio.create_task(_heartbeat_loop(ws))
-
         # Message loop: handle incoming RPC + events
         # CRITICAL: RPC 死锁防范
         # - 入站 RPC 请求必须用 create_task() 异步执行，不可 await
@@ -622,19 +621,16 @@ async def _rpc_call(ws, method: str, params: dict = None):
     await ws.send(json.dumps(msg))
 
 
-async def _heartbeat_loop(ws):
-    """Send registry.heartbeat every 30 seconds to prevent TTL expiration."""
-    while True:
-        try:
-            await asyncio.sleep(30)
-            if not _shutting_down:
-                await _rpc_call(ws, "registry.heartbeat", {"module_id": "watchdog"})
-        except Exception as e:
-            print(f"[watchdog] Heartbeat error: {e}")
-            break
+async def _publish_event(ws, event: dict):
+    """Publish an event via RPC event.publish."""
+    await _rpc_call(ws, "event.publish", {
+        "event_id": str(uuid.uuid4()),
+        "event": event.get("event", ""),
+        "data": event.get("data", {}),
+    })
 
 
-async def _rpc_call_with_response(ws, method: str, params: dict = None, timeout: float = 5) -> dict:
+async def _rpc_call_with_response(ws, method: str, params: dict = None, timeout: float = 5):
     """Send a JSON-RPC 2.0 request and await the response."""
     rpc_id = str(uuid.uuid4())
     msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
@@ -665,12 +661,32 @@ async def _publish_event(ws, event: dict):
     })
 
 
+async def _handle_ping_event(data: dict):
+    """Handle system.ping event and reply with system.pong."""
+    t1 = data.get("ping_time")
+    t2 = time.time()
+
+    await _publish_event(_ws_global, {
+        "event": "system.pong",
+        "data": {
+            "module_id": MODULE_NAME,
+            "ping_time": t1,
+            "pong_time": t2,
+        },
+    })
+
+
 async def _handle_event_notification(msg: dict, monitor: HealthMonitor):
     """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
     params = msg.get("params", {})
     event_type = params.get("event", "")
     data = params.get("data", {})
 
+    # Handle system.ping event
+    if event_type == "system.ping":
+        await _handle_ping_event(data)
+        return
+
     # Debug: log all shutdown events
     if event_type == "module.shutdown":
         target = data.get("module_id", "")
@@ -713,11 +729,21 @@ async def _handle_rpc_request(ws, msg: dict, monitor: HealthMonitor):
 
 async def _rpc_health(monitor: HealthMonitor) -> dict:
     """RPC handler for watchdog.health."""
+    # 统计不健康的模块数量
+    unhealthy_count = sum(1 for s in monitor.modules.values() if s.state == "unhealthy")
+    # 统计资源严重不足的模块数量
+    critical_resources = sum(1 for s in monitor.modules.values() if s.resource_state == "critical")
+    # 统计总重启次数
+    total_restarts = sum(s.restarted_count for s in monitor.modules.values())
+
     return {
         "status": "healthy",
+        "uptime_seconds": round(time.time() - _start_ts),
         "details": {
             "monitored_modules": len(monitor.modules),
-            "uptime_seconds": round(time.time() - _start_ts),
+            "unhealthy_modules": unhealthy_count,
+            "critical_resources": critical_resources,
+            "total_restarts": total_restarts,
         },
     }
 

package/extensions/services/watchdog/module.md

@@ -6,6 +6,7 @@ type: service
 state: enabled
 runtime: python
 entry: entry.py
+display_order: 99
 events:
   - watchdog.module.unhealthy
   - watchdog.module.recovered

package/extensions/services/watchdog/monitor.py

@@ -55,6 +55,8 @@ class ModuleStatus:
         self.memory_samples: list[float] = []  # last 5 memory_rss samples
         self.recovery_since: float = 0  # when recovery observation started
         self.last_metrics: dict = {}
+        # Startup metrics
+        self.startup_time: float = 0  # module startup time in seconds (from module.ready event)
 
 
 class HealthMonitor:
@@ -409,6 +411,10 @@ class HealthMonitor:
             return
 
         if not module_id or module_id == "watchdog":
+            # Handle registry.updated (no module_id)
+            if event_type == "registry.updated":
+                # Registry changed, re-discover modules
+                asyncio.create_task(self.discover_modules())
             return
 
         if event_type == "module.started":
@@ -421,6 +427,8 @@ class HealthMonitor:
         elif event_type == "module.stopped":
             print(f"[watchdog] Received module.stopped: {module_id}")
             self.modules.pop(module_id, None)
+            # Re-discover to update module list
+            asyncio.create_task(self.discover_modules())
             await self._handle_module_stopped(module_id, data)
 
         elif event_type == "module.exiting":
@@ -441,8 +449,12 @@ class HealthMonitor:
 
         elif event_type == "module.ready":
             graceful = bool(data.get("graceful_shutdown"))
-            print(f"[watchdog] Received module.ready: {module_id}, graceful_shutdown={graceful}")
+            startup_time = data.get("startup_time", 0)
+            print(f"[watchdog] Received module.ready: {module_id}, graceful_shutdown={graceful}, startup_time={startup_time:.3f}s")
             self._graceful_modules[module_id] = graceful
+            # Save startup time to module status
+            if module_id in self.modules:
+                self.modules[module_id].startup_time = startup_time
             # Reset launcher loss tracking when launcher reconnects
             if module_id == "launcher":
                 self._launcher_offline = False
@@ -694,10 +706,15 @@ class HealthMonitor:
             return
         print("[watchdog] system.ready received, starting health checks")
 
-        while self._running:
-            # Re-discover every cycle to pick up newly started/stopped modules
-            await self.discover_modules()
+        # Initial discovery (first time)
+        await self.discover_modules()
+
+        # Track discovery count and last discovery time
+        discovery_count = 1
+        last_discovery = asyncio.get_event_loop().time()
+        discovery_interval = 300.0  # 5 minutes after first 2 discoveries
 
+        while self._running:
             if self.modules:
                 tasks = []
                 for s in self.modules.values():
@@ -709,6 +726,18 @@ class HealthMonitor:
             interval = self._min_interval()
             await asyncio.sleep(interval)
 
+            # Periodic re-discovery
+            now = asyncio.get_event_loop().time()
+            if discovery_count < 2:
+                # First 2 times: discover every cycle
+                await self.discover_modules()
+                discovery_count += 1
+                last_discovery = now
+            elif now - last_discovery >= discovery_interval:
+                # After that: discover every 5 minutes
+                await self.discover_modules()
+                last_discovery = now
+
     def _min_interval(self) -> float:
         """Return the shortest check interval needed across all modules."""
         if not self.modules:
@@ -732,6 +761,7 @@ class HealthMonitor:
                 "last_error": s.last_error,
                 "resource_state": s.resource_state,
                 "metrics": s.last_metrics,
+                "startup_time": s.startup_time,
             }
             for mid, s in self.modules.items()
         }

package/extensions/services/web/module.md

@@ -3,7 +3,7 @@ name: web
 display_name: Web Management
 version: '1.0'
 type: service
-state: enabled
+state: manual
 runtime: python
 entry: entry.py
 preferred_port: 18766

package/extensions/services/web/server.py

@@ -305,7 +305,7 @@ class WebServer:
         url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={self.token}&id=web"
         print(f"[web] WS connecting to Kernel")
         try:
-            async with websockets.connect(url, open_timeout=5, ping_interval=20, ping_timeout=20, close_timeout=10) as ws:
+            async with websockets.connect(url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
                 self._ws = ws
                 elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                 elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
@@ -364,17 +364,18 @@ class WebServer:
 
                 # Send module.ready (every reconnect, not just first time)
                 if not self._shutting_down:
+                    startup_time = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
                     await self._rpc_call(ws, "event.publish", {
                         "event_id": str(uuid.uuid4()),
                         "event": "module.ready",
                         "data": {
                             "module_id": "web",
                             "graceful_shutdown": True,
+                            "startup_time": startup_time,
                         },
                     })
-                    elapsed = time.monotonic() - self.boot_t0 if self.boot_t0 else 0
-                    elapsed_str = f" ({elapsed:.1f}s)" if elapsed else ""
-                    print(f"[web] module.ready sent{elapsed_str}")
+                    elapsed_str = self._fmt_elapsed(self.boot_t0)
+                    print(f"[web] module.ready published ({elapsed_str})")
 
                     # Publish web.started event with access URL
                     display_host = "localhost" if self.host == "0.0.0.0" else self.host
@@ -397,9 +398,6 @@ class WebServer:
                 # - 事件通知和 RPC 响应可以同步处理（它们不会反向调用 rpc_call）
                 print(f"[web] Entering receive loop")
 
-                # Start heartbeat loop
-                heartbeat_task = asyncio.create_task(self._heartbeat_loop(ws))
-
                 try:
                     async for raw in ws:
                         try:
@@ -443,16 +441,20 @@ class WebServer:
             msg["params"] = params
         await ws.send(json.dumps(msg))
 
-    async def _heartbeat_loop(self, ws):
-        """Send registry.heartbeat every 30 seconds to prevent TTL expiration."""
-        while True:
-            try:
-                await asyncio.sleep(30)
-                if not self._shutting_down:
-                    await self._rpc_call(ws, "registry.heartbeat", {"module_id": "web"})
-            except Exception as e:
-                print(f"[web] Heartbeat error: {e}")
-                break
+    async def _handle_ping_event(self, data: dict):
+        """Handle system.ping event and reply with system.pong."""
+        import time
+        t1 = data.get("ping_time")
+        t2 = time.time()
+
+        await self._publish_event({
+            "event": "system.pong",
+            "data": {
+                "module_id": "web",
+                "ping_time": t1,
+                "pong_time": t2,
+            },
+        })
 
     async def _handle_event_notification(self, msg: dict):
         """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
@@ -460,6 +462,11 @@ class WebServer:
         event_type = params.get("event", "")
         data = params.get("data", {})
 
+        # Handle system.ping event
+        if event_type == "system.ping":
+            await self._handle_ping_event(data)
+            return
+
         # Log all events for debugging
         print(f"[web] Event received: {event_type}, data: {data}")
 
@@ -532,10 +539,15 @@ class WebServer:
 
     async def _rpc_health(self) -> dict:
         """RPC handler for web.health."""
+        # 获取 WebSocket 连接数
+        from routes.routes_management_ws import _management_clients
+        active_connections = len(_management_clients)
+
         return {
             "status": "healthy",
+            "uptime_seconds": round(time.time() - self._start_time),
             "details": {
-                "uptime_seconds": round(time.time() - self._start_time),
+                "active_ws_connections": active_connections,
             },
         }
 

package/extensions/services/web/static/js/token-manager.js

@@ -5,7 +5,7 @@
 
 // Load tokens on page load
 async function loadTokens() {
-  console.log('[token-manager] loadTokens() called');
+  console.log('[web] loadTokens() called');
 
   // 立即显示加载中
   const tbody = document.getElementById('tokens-tbody');
@@ -18,16 +18,16 @@ async function loadTokens() {
   try {
     // Use kernel client to call RPC
     if (!kernelClient || !kernelClient.connected) {
-      console.error('[token-manager] kernelClient not ready:', { kernelClient, connected: kernelClient?.connected });
+      console.error('[web] kernelClient not ready:', { kernelClient, connected: kernelClient?.connected });
       throw new Error('WebSocket 未连接');
     }
 
-    console.log('[token-manager] Calling web.list_tokens...');
+    console.log('[web] Calling web.list_tokens...');
     const result = await kernelClient.call('web.list_tokens', {});
-    console.log('[token-manager] Got result:', result);
+    console.log('[web] Got result:', result);
     renderTokens(result.tokens || []);
   } catch (err) {
-    console.error('[token-manager] Failed to load tokens:', err);
+    console.error('[web] Failed to load tokens:', err);
 
     // 根据错误类型显示不同的提示
     let errorMsg = err.message;
@@ -126,7 +126,7 @@ async function revokeToken(token) {
     await kernelClient.call('web.revoke_token', { token });
 
   } catch (err) {
-    console.error('[token-manager] Failed to revoke token:', err);
+    console.error('[web] Failed to revoke token:', err);
 
     // 失败后恢复该行
     const row = event.target.closest('tr');
@@ -140,7 +140,7 @@ async function revokeToken(token) {
       ? '权限不足：无法吊销 Token'
       : `吊销失败: ${err.message}`;
 
-    console.error('[token-manager]', errorMsg);
+    console.error('[web]', errorMsg);
   }
 }
 
@@ -157,7 +157,7 @@ document.addEventListener('DOMContentLoaded', () => {
     modulesNav.addEventListener('click', () => {
       // Wait a bit for page switch, then load tokens
       setTimeout(() => {
-        console.log('[token-manager] Modules page clicked, loading tokens...');
+        console.log('[web] Modules page clicked, loading tokens...');
         loadTokens();
       }, 100);
     });
@@ -165,10 +165,10 @@ document.addEventListener('DOMContentLoaded', () => {
 
   // Wait for kernelClient to be ready before loading tokens
   window.addEventListener('kernelClientReady', () => {
-    console.log('[token-manager] kernelClient ready');
+    console.log('[web] kernelClient ready');
     // Load tokens if modules page is active on load
     if (document.getElementById('page-modules').classList.contains('active')) {
-      console.log('[token-manager] Modules page is active, loading tokens...');
+      console.log('[web] Modules page is active, loading tokens...');
       loadTokens();
     }
   });

package/kernel/entry.py

@@ -460,7 +460,7 @@ def main():
     launcher_token = secrets.token_urlsafe(32)
 
     # Step 3: Create KernelServer with launcher_token
-    server = KernelServer(launcher_token=launcher_token, advertise_ip=advertise_ip, module_id=MODULE_NAME)
+    server = KernelServer(launcher_token=launcher_token, advertise_ip=advertise_ip, module_id=MODULE_NAME, boot_t0=_t0)
 
     # Step 4: Bind port
     bind_host = advertise_ip