@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/web/static/js/app.js

@@ -4782,9 +4782,41 @@ async function loadModuleStats() {
             events: counters,
             rpcStats
         };
+
+        // Update stats info panel
+        updateStatsInfo(true, eventsRouted, rpcCalls);
     } catch (err) {
         console.error('[stats] Load failed:', err);
         // Don't clear UI on error, keep last known values
+        updateStatsInfo(false, 0, 0, err.message);
+    }
+}
+
+function updateStatsInfo(success, eventsCount, rpcCount, errorMsg = null) {
+    const infoPanel = document.getElementById('stats-update-info');
+    const statusEl = document.getElementById('stats-update-status');
+    const lastUpdateEl = document.getElementById('stats-last-update');
+    const eventsCountEl = document.getElementById('stats-events-count');
+    const rpcCountEl = document.getElementById('stats-rpc-count');
+
+    if (!infoPanel) return;
+
+    // Update status
+    const now = new Date();
+    const timeStr = now.toLocaleTimeString('zh-CN', { hour12: false });
+
+    if (success) {
+        statusEl.textContent = '✓ 已更新';
+        statusEl.style.color = '#28a745';
+        lastUpdateEl.textContent = `最后更新: ${timeStr}`;
+        eventsCountEl.textContent = eventsCount;
+        rpcCountEl.textContent = rpcCount;
+        infoPanel.style.borderLeftColor = '#28a745';
+    } else {
+        statusEl.textContent = `✗ 更新失败${errorMsg ? ': ' + errorMsg : ''}`;
+        statusEl.style.color = '#dc3545';
+        lastUpdateEl.textContent = `失败时间: ${timeStr}`;
+        infoPanel.style.borderLeftColor = '#dc3545';
     }
 }
 

package/extensions/services/web/static/js/kernel-client.js

@@ -27,9 +27,13 @@ class KernelClient {
 
         // 重连配置
         this.reconnectDelay = 1000; // 1秒
-        this.maxReconnectDelay = 10000; // 10秒
+        this.maxReconnectDelay = 15000; // 15秒
         this.reconnectAttempts = 0;
         this.reconnectTimer = null;
+        this.fatalError = false; // 是否遇到永久性错误（不应重试）
+        this.jitterRatio = 0.2; // Jitter 比例
+        this.lastCloseCode = null; // 最后一次关闭码
+        this.cooldownAttempts = 0; // 速率限制重试次数
 
         // 心跳配置
         this.heartbeatInterval = 20000; // 20秒
@@ -274,6 +278,7 @@ class KernelClient {
             this.connected = true;
             this.reconnectAttempts = 0;
             this.reconnectDelay = 1000;
+            this.cooldownAttempts = 0;
             this._startHeartbeat();
             onOpen(ws);
         };
@@ -283,8 +288,9 @@ class KernelClient {
             if (onError) onError(error);
         };
 
-        ws.onclose = () => {
-            console.log('[KernelClient] WebSocket closed');
+        ws.onclose = (event) => {
+            console.log('[KernelClient] WebSocket closed, code=', event.code);
+            this.lastCloseCode = event.code;
             this.connected = false;
             this.authenticated = false;
             this.ws = null;
@@ -348,15 +354,48 @@ class KernelClient {
      * 内部：安排重连
      */
     _scheduleReconnect() {
+        console.log('[KernelClient] DEBUG_RECONNECT: fatalError=', this.fatalError, 'reconnectTimer=', !!this.reconnectTimer, 'lastCloseCode=', this.lastCloseCode);
+
         if (this.reconnectTimer) return;
 
-        this.reconnectAttempts++;
-        const delay = Math.min(
-            this.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1),
-            this.maxReconnectDelay
-        );
+        const code = this.lastCloseCode;
+
+        // never: 永不重连
+        if ([4001, 4003, 4004, 1008, 4010, 1000].includes(code)) {
+            this.fatalError = true;
+            console.error('[KernelClient] Fatal error detected (code ' + code + '), reconnection disabled');
+            return;
+        }
 
-        console.log(`[KernelClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        // 如果已经标记为 fatalError，不再重连
+        if (this.fatalError) {
+            console.error('[KernelClient] Fatal error detected, reconnection disabled');
+            return;
+        }
+
+        let delay;
+
+        // cooldown: 速率限制
+        if (code === 4020) {
+            this.cooldownAttempts++;
+            if (this.cooldownAttempts >= 5) {
+                this.fatalError = true;
+                console.error('[KernelClient] Rate limit exceeded, reconnection disabled');
+                return;
+            }
+            delay = 10000;
+            console.log(`[KernelClient] Rate limited, reconnecting in ${delay}ms (${this.cooldownAttempts}/5)`);
+        } else {
+            // standard: 指数退避 + jitter
+            this.reconnectAttempts++;
+            const base = Math.min(
+                this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+                this.maxReconnectDelay
+            );
+            const jitter = base * this.jitterRatio * Math.random();
+            delay = Math.round(base + jitter);
+            console.log(`[KernelClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+        }
 
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;

package/extensions/services/web/vendor/bluetooth/audio.py

@@ -20,7 +20,7 @@ from .. import config as cfg
 logger = logging.getLogger("bluetooth.audio")
 
 # ---------------------------------------------------------------------------
-# Audio format constants (must match config.yaml defaults)
+# Audio format constants (must match config.json5 defaults)
 # ---------------------------------------------------------------------------
 SAMPLE_RATE = 16_000
 CHANNELS = 1

package/extensions/services/web/vendor/config.py

@@ -12,7 +12,7 @@ import yaml
 _VENDOR_DIR = Path(__file__).resolve().parent
 _MODULE_DIR = _VENDOR_DIR.parent  # extensions/services/web/
 _ROOT = _MODULE_DIR
-_DEFAULT_CONFIG_PATH = _MODULE_DIR / "config.yaml"
+_DEFAULT_CONFIG_PATH = _MODULE_DIR / "config.json5"
 _RUNTIME_CONFIG_PATH: Path | None = None
 _load_error: str | None = None  # set when config loading fails
 
@@ -51,7 +51,7 @@ def load_config() -> dict[str, Any]:
     if not _DEFAULT_CONFIG_PATH.exists():
         _load_error = (
             f"默认配置文件不存在: {_DEFAULT_CONFIG_PATH}\n"
-            f"请将 config.yaml 放到 Web 模块目录: {_MODULE_DIR}"
+            f"请将 config.json5 放到 Web 模块目录: {_MODULE_DIR}"
         )
         _config = {}
         return _config

package/extensions/services/web/vendor/storage/identity.py

@@ -250,7 +250,7 @@ def _get_owners_list() -> list[dict[str, Any]]:
 def is_owner(user_phone: str, contact_phone: str) -> bool:
     """Check if the contact is an owner.
 
-    Single source of truth: ``config.yaml`` → ``user.owners``.
+    Single source of truth: ``config.json5`` → ``user.owners``.
     """
     clean_contact = sanitize_phone(contact_phone)
     return any(

package/kernel/entry.py

@@ -22,7 +22,7 @@ import time
 import traceback
 from datetime import datetime, timezone
 
-import uvicorn
+# uvicorn 延迟导入（在端口输出之后），加速端口返回
 
 
 # ── Module configuration ──
@@ -359,22 +359,30 @@ _project_root = os.environ.get("KITE_PROJECT") or os.path.dirname(os.path.dirnam
 if _project_root not in sys.path:
     sys.path.insert(0, _project_root)
 
-from kernel.server import KernelServer
+# KernelServer 延迟导入（在端口输出之后），加速端口返回
 
 
-def _bind_port(preferred: int, host: str) -> int:
-    """Try preferred port first, fall back to OS-assigned."""
+def _bind_port(preferred: int, host: str) -> tuple[socket.socket, int]:
+    """Try preferred port first, fall back to OS-assigned.
+
+    Returns:
+        (bound_socket, port) — socket 保持绑定状态，由调用方传给 uvicorn
+    """
+    def _try_bind(port_num: int) -> tuple[socket.socket, int]:
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind((host, port_num))
+        s.listen(128)
+        s.setblocking(False)
+        return s, s.getsockname()[1]
+
     if preferred:
         try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind((host, preferred))
-                return preferred
+            return _try_bind(preferred)
         except OSError as e:
             print(f"\033[31m[kernel] ✖ 指定端口 {preferred} 绑定失败: {e}，将使用系统随机端口\033[0m")
     try:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind((host, 0))
-            return s.getsockname()[1]
+        return _try_bind(0)
     except OSError as e:
         print(f"\033[31m[kernel] ✖ 端口绑定完全失败 ({host}): {e}\033[0m")
         raise
@@ -447,44 +455,90 @@ def main():
 
     # Kite environment
     is_debug = os.environ.get("KITE_DEBUG") == "1"
+    is_recover = os.environ.get("KITE_KERNEL_RECOVER") == "1"
 
     if is_debug:
         print("[kernel] 调试模式已启用 (KITE_DEBUG=1)，接受所有令牌")
 
+    # Step 0.5: 恢复模式 — 从 stdin 读取端口和 Token（必须在 bind 之前）
+    recover_tokens = {}
+    if is_recover:
+        print("[kernel] 恢复模式 (KITE_KERNEL_RECOVER=1)，从 stdin 读取恢复数据...")
+        recover_data = _read_stdin_kite_messages({"recover"}, timeout=5)
+        if "recover" in recover_data:
+            rmsg = recover_data["recover"]
+            recover_port = rmsg.get("port", 0)
+            recover_tokens = rmsg.get("tokens", {})
+            print(f"[kernel] 恢复数据: port={recover_port}, tokens={len(recover_tokens)}")
+        else:
+            print("[kernel] 警告: 未收到恢复数据，使用默认配置")
+            recover_port = 0
+
     # Step 1: Use cached module config (already loaded at module level)
     advertise_ip = _module_config["advertise_ip"]
     preferred_port = _module_config["preferred_port"]
 
-    # Step 2: Generate launcher token
-    import secrets
-    launcher_token = secrets.token_urlsafe(32)
+    # 恢复模式的端口优先级最高
+    if is_recover and recover_port:
+        preferred_port = recover_port
 
-    # Step 3: Create KernelServer with launcher_token
-    server = KernelServer(launcher_token=launcher_token, advertise_ip=advertise_ip, module_id=MODULE_NAME, boot_t0=_t0)
-
-    # Step 4: Bind port
+    # Step 2: Bind port early and keep socket open (before creating KernelServer)
+    # Socket 保持监听状态，Launcher 拿到端口后连接不会被拒绝
     bind_host = advertise_ip
-    port = _bind_port(preferred_port, bind_host)
-    server.port = port
+    bound_sock, port = _bind_port(preferred_port, bind_host)
 
-    # Step 5: Output port + launcher_token via stdout
+    # Step 3: Output port via stdout (as early as possible)
+    import secrets
+    launcher_token = secrets.token_urlsafe(32)
     print(json.dumps({"kite": "port", "port": port, "token": launcher_token}), flush=True)
 
     print(f"[kernel] 启动中 {bind_host}:{port} ({_fmt_elapsed(_t0)})")
 
+    # Step 3.5: 延迟导入重量级依赖（uvicorn + KernelServer），端口已输出
+    import uvicorn
+    from kernel.server import KernelServer
+
+    # Step 4: Create KernelServer (after port output)
+    server = KernelServer(launcher_token=launcher_token, advertise_ip=advertise_ip, module_id=MODULE_NAME, boot_t0=_t0, is_recover=is_recover)
+    server.port = port
+
     # Step 6: Self-register in registry (direct memory write)
     server.self_register()
 
-    # Step 7: Start uvicorn (module.ready will be published when Launcher subscribes)
+    # Step 6.1: 恢复模式 — 注册旧模块 Token + 关闭 init gate
+    if is_recover and recover_tokens:
+        server.registry.register_tokens(recover_tokens)
+        server._init_gate_open = False  # 恢复模式：暂缓 require_init，等 Launcher 就绪后打开
+        print(f"[kernel] 已恢复 {len(recover_tokens)} 个模块 token")
+
+    # Step 6.5: Start debug API server (if enabled)
+    if server.debug_app:
+        debug_sock, debug_port = _bind_port(18770, bind_host)  # debug 模式固定端口
+        debug_sock.close()  # debug server 自行绑定即可
+        server.debug_port = debug_port
+        print(f"[kernel] Debug API: http://{bind_host}:{debug_port}", flush=True)
+
+        # 在后台线程启动 debug server
+        import threading
+        def _run_debug_server():
+            debug_config = uvicorn.Config(server.debug_app, host=bind_host, port=debug_port, log_level="error")
+            debug_server = uvicorn.Server(debug_config)
+            server._debug_server = debug_server
+            debug_server.run()
+
+        debug_thread = threading.Thread(target=_run_debug_server, daemon=True)
+        debug_thread.start()
+
+    # Step 7: Start uvicorn,复用已绑定的 socket（端口输出后即可接受连接，无间隙）
     try:
-        config = uvicorn.Config(server.app, host=bind_host, port=port, log_level="warning")
+        config = uvicorn.Config(server.app, log_level="warning")
         uvi_server = uvicorn.Server(config)
         server._uvicorn_server = uvi_server
 
         # module.ready is now published when Launcher subscribes (not at startup)
         # This ensures Launcher is connected and subscribed before receiving the event
 
-        uvi_server.run()
+        uvi_server.run(sockets=[bound_sock])
     except Exception as e:
         _write_crash(type(e), e, e.__traceback__, severity="critical", handled=True)
         _print_crash_summary(type(e), e.__traceback__)