@agentunion/kite 1.5.0 → 1.6.0

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

@@ -0,0 +1,560 @@
+/**
+ * Kernel WebSocket 客户端
+ *
+ * 功能：
+ * - 配对/认证
+ * - 自动重连
+ * - RPC 调用
+ * - 事件订阅
+ * - Token 续期
+ */
+
+class KernelClient {
+    constructor(url) {
+        this.url = url;
+        this.ws = null;
+        this.moduleId = null;
+        this.role = null;
+        this.connected = false;
+        this.authenticated = false;
+
+        // RPC 请求管理
+        this.rpcId = 0;
+        this.pendingRpcs = new Map(); // id -> {resolve, reject, timeout}
+
+        // 事件监听器
+        this.eventListeners = new Map(); // event -> [callbacks]
+
+        // 连接状态回调
+        this.onConnectionChange = null; // (status, message) => void
+        // status: 'connected' | 'disconnected' | 'reconnecting' | 'error'
+
+        // 认证成功回调（在认证完成后触发，用于重新订阅事件等）
+        this.onAuthenticated = null; // (reconnected: boolean) => void
+
+        // 重连配置
+        this.reconnectDelay = 1000; // 1秒
+        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秒
+        this.heartbeatTimer = null;
+
+        // Token 管理
+        // 优先使用 kiteToken（Evol 业务），其次使用 frontend_token（配对码）
+        this.token = localStorage.getItem('kiteToken') || localStorage.getItem('frontend_token');
+        this.sessionToken = sessionStorage.getItem('session_token');
+
+        // 生成 session_token（如果没有）
+        if (!this.sessionToken) {
+            this.sessionToken = 'sess_' + this._randomString(6);
+            sessionStorage.setItem('session_token', this.sessionToken);
+        }
+
+        // 流量统计
+        this.bytesReceived = 0;
+        this.bytesSent = 0;
+        // 最后消息时间
+        this.lastMessageTime = null;
+    }
+
+    /**
+     * 配对（首次使用）
+     */
+    async pair(code) {
+        return new Promise((resolve, reject) => {
+            this._connect((ws) => {
+                // 发送配对消息
+                const pairMsg = JSON.stringify({
+                    type: 'pair',
+                    code: code
+                });
+                ws.send(pairMsg);
+                this.bytesSent += pairMsg.length;
+
+                // 等待响应
+                const handler = (event) => {
+                    this.bytesReceived += event.data.length;
+                    const msg = JSON.parse(event.data);
+
+                    if (msg.type === 'paired') {
+                        // 配对成功
+                        this.token = msg.token;
+                        this.sessionToken = msg.session_token;
+                        this.moduleId = msg.module_id;
+                        this.role = msg.role;
+
+                        // 保存 token
+                        localStorage.setItem('frontend_token', this.token);
+                        sessionStorage.setItem('session_token', this.sessionToken);
+
+                        this.authenticated = true;
+                        ws.removeEventListener('message', handler);
+                        resolve({
+                            moduleId: this.moduleId,
+                            role: this.role
+                        });
+                    } else if (msg.type === 'error') {
+                        // 配对失败
+                        ws.removeEventListener('message', handler);
+                        reject(new Error(msg.message));
+                    }
+                };
+
+                ws.addEventListener('message', handler);
+            }, reject);
+        });
+    }
+
+    /**
+     * 连接（已有 token）
+     */
+    async connect() {
+        if (!this.token) {
+            throw new Error('No token found, please pair first');
+        }
+
+        return new Promise((resolve, reject) => {
+            this._connect((ws) => {
+                // 发送认证消息
+                const authMsg = JSON.stringify({
+                    type: 'auth',
+                    token: this.token,
+                    session_token: this.sessionToken
+                });
+                ws.send(authMsg);
+                this.bytesSent += authMsg.length;
+
+                // 等待响应
+                const handler = (event) => {
+                    this.bytesReceived += event.data.length;
+                    const msg = JSON.parse(event.data);
+
+                    if (msg.type === 'authenticated' || msg.type === 'reconnected') {
+                        // 认证成功
+                        this.moduleId = msg.module_id;
+                        this.role = msg.role;
+                        this.authenticated = true;
+
+                        ws.removeEventListener('message', handler);
+
+                        // 触发认证成功回调
+                        const isReconnected = msg.type === 'reconnected';
+                        if (this.onAuthenticated) {
+                            try {
+                                this.onAuthenticated(isReconnected);
+                            } catch (e) {
+                                console.error('[KernelClient] onAuthenticated callback error:', e);
+                            }
+                        }
+
+                        resolve({
+                            moduleId: this.moduleId,
+                            role: this.role,
+                            reconnected: isReconnected
+                        });
+                    } else if (msg.type === 'error') {
+                        // 认证失败
+                        ws.removeEventListener('message', handler);
+
+                        // 保存服务端报告的 Kernel 重连状态
+                        if (msg.kernel_status) {
+                            this._lastKernelStatus = msg.kernel_status;
+                            this._serverRetryAfterMs = msg.retry_after_ms || 0;
+                            const ks = msg.kernel_status;
+                            console.warn(`[KernelClient] Kernel status: ${ks.state} (attempt ${ks.attempt}/${ks.max_attempts}, server retry in ${ks.next_retry_ms}ms, suggest client retry in ${msg.retry_after_ms}ms)`);
+                        }
+
+                        // 检查是否为永久性错误
+                        if (msg.fatal) {
+                            this.fatalError = true;
+                            console.error('[KernelClient] Fatal error, will not retry:', msg.message);
+                        }
+
+                        // 服务端标记为 fatal/exiting 且不建议重连
+                        if (msg.kernel_status && (msg.kernel_status.state === 'fatal' || msg.kernel_status.state === 'exiting') && !msg.retry_after_ms) {
+                            this.fatalError = true;
+                            console.error(`[KernelClient] Server kernel ${msg.kernel_status.state}, reconnection disabled`);
+                        }
+
+                        // 如果是 token 无效，清除本地 token
+                        if (msg.message.includes('Invalid') || msg.message.includes('expired')) {
+                            localStorage.removeItem('frontend_token');
+                            this.token = null;
+                        }
+
+                        reject(new Error(msg.message));
+                    }
+                };
+
+                ws.addEventListener('message', handler);
+            }, reject);
+        });
+    }
+
+    /**
+     * 调用 RPC
+     */
+    async call(method, params = {}, timeout = 30000) {
+        if (!this.authenticated) {
+            throw new Error('Not authenticated');
+        }
+
+        return new Promise((resolve, reject) => {
+            const id = `rpc-${++this.rpcId}`;
+
+            // 发送 RPC 请求
+            const rpcMsg = JSON.stringify({
+                jsonrpc: '2.0',
+                id: id,
+                method: method,
+                params: params
+            });
+            this.ws.send(rpcMsg);
+            this.bytesSent += rpcMsg.length;
+
+            // 设置超时
+            const timer = setTimeout(() => {
+                this.pendingRpcs.delete(id);
+                reject(new Error(`RPC timeout: ${method}`));
+            }, timeout);
+
+            // 保存 pending RPC
+            this.pendingRpcs.set(id, { resolve, reject, timeout: timer });
+        });
+    }
+
+    /**
+     * 订阅事件
+     */
+    async subscribe(events) {
+        return this.call('event.subscribe', { events });
+    }
+
+    /**
+     * 监听事件
+     */
+    on(event, callback) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, []);
+        }
+        this.eventListeners.get(event).push(callback);
+    }
+
+    /**
+     * 取消监听事件
+     */
+    off(event, callback) {
+        if (!this.eventListeners.has(event)) return;
+
+        const listeners = this.eventListeners.get(event);
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+            listeners.splice(index, 1);
+        }
+    }
+
+    /**
+     * 断开连接
+     */
+    disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+
+        this._stopHeartbeat();
+
+        if (this.ws) {
+            // 发送 disconnect 消息
+            try {
+                const disconnectMsg = JSON.stringify({ type: 'disconnect' });
+                this.ws.send(disconnectMsg);
+                this.bytesSent += disconnectMsg.length;
+            } catch (e) {
+                // Ignore
+            }
+
+            this.ws.close();
+            this.ws = null;
+        }
+
+        this.connected = false;
+        this.authenticated = false;
+    }
+
+    /**
+     * 启动心跳
+     */
+    _startHeartbeat() {
+        this._stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                try {
+                    // 发送 ping 消息
+                    const pingMsg = JSON.stringify({ type: 'ping' });
+                    this.ws.send(pingMsg);
+                    this.bytesSent += pingMsg.length;
+                } catch (e) {
+                    console.error('[KernelClient] Heartbeat failed:', e);
+                }
+            }
+        }, this.heartbeatInterval);
+    }
+
+    /**
+     * 停止心跳
+     */
+    _stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+
+    /**
+     * 内部：建立 WebSocket 连接
+     */
+    _connect(onOpen, onError) {
+        // 已连接，直接回调
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            onOpen(this.ws);
+            return;
+        }
+
+        // 正在连接中，等待结果而不是创建新连接
+        if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+            const ws = this.ws;
+            const onOpenOnce = () => {
+                ws.removeEventListener('open', onOpenOnce);
+                ws.removeEventListener('error', onErrorOnce);
+                onOpen(ws);
+            };
+            const onErrorOnce = (e) => {
+                ws.removeEventListener('open', onOpenOnce);
+                ws.removeEventListener('error', onErrorOnce);
+                if (onError) onError(e);
+            };
+            ws.addEventListener('open', onOpenOnce);
+            ws.addEventListener('error', onErrorOnce);
+            return;
+        }
+
+        const ws = new WebSocket(this.url);
+
+        ws.onopen = () => {
+            console.log('[KernelClient] WebSocket connected');
+            this.ws = ws;
+            this.connected = true;
+            this.reconnectAttempts = 0;
+            this.reconnectDelay = 1000;
+            this.cooldownAttempts = 0;
+            this._startHeartbeat();
+
+            // 通知连接状态变化
+            if (this.onConnectionChange) {
+                this.onConnectionChange('connected', 'WebSocket 已连接');
+            }
+
+            onOpen(ws);
+        };
+
+        ws.onerror = (error) => {
+            console.error('[KernelClient] WebSocket error:', error);
+            if (onError) onError(error);
+        };
+
+        ws.onclose = (event) => {
+            // DEBUG: 诊断模块测试 "Not authenticated" 问题
+            console.error(`[KernelClient] DEBUG: ws.onclose fired — code=${event.code}, reason="${event.reason}", wasClean=${event.wasClean}, time=${new Date().toISOString()}`);
+            console.trace('DEBUG: ws.onclose stack trace');
+            this.lastCloseCode = event.code;
+            this.connected = false;
+            this.authenticated = false;
+            this.ws = null;
+            this._stopHeartbeat();
+
+            // Token 被吊销（被管理员断开），清除 token 并通知上层跳转登录页
+            if (event.code === 4001 && event.reason === 'Token revoked') {
+                localStorage.removeItem('frontend_token');
+                this.token = null;
+                this.fatalError = true;
+                if (this.onConnectionChange) {
+                    this.onConnectionChange('revoked', '连接已被管理员断开，需要重新配对');
+                }
+                return;
+            }
+
+            // 通知连接状态变化
+            if (this.onConnectionChange) {
+                this.onConnectionChange('disconnected', 'WebSocket 已断开');
+            }
+
+            // 自动重连（如果有 token）
+            if (this.token) {
+                this._scheduleReconnect();
+            }
+        };
+
+        ws.onmessage = (event) => {
+            this.bytesReceived += event.data.length;
+            this.lastMessageTime = Date.now();
+            this._handleMessage(event.data);
+        };
+    }
+
+    /**
+     * 内部：处理消息
+     */
+    _handleMessage(raw) {
+        try {
+            const msg = JSON.parse(raw);
+
+            // RPC 响应
+            if (msg.id && this.pendingRpcs.has(msg.id)) {
+                const { resolve, reject, timeout } = this.pendingRpcs.get(msg.id);
+                clearTimeout(timeout);
+                this.pendingRpcs.delete(msg.id);
+
+                if (msg.error) {
+                    reject(new Error(msg.error.message || 'RPC error'));
+                } else {
+                    resolve(msg.result);
+                }
+                return;
+            }
+
+            // 事件通知
+            if (msg.method === 'event' || !msg.id) {
+                const params = msg.params || {};
+                const event = params.event;
+                const data = params.data || {};
+
+                // 触发精确匹配的监听器
+                if (event && this.eventListeners.has(event)) {
+                    const listeners = this.eventListeners.get(event);
+                    listeners.forEach(callback => {
+                        try {
+                            callback(data);
+                        } catch (e) {
+                            console.error('[KernelClient] Event listener error:', e);
+                        }
+                    });
+                }
+
+                // 触发通配符监听器（'>' 监听所有事件）
+                if (event && this.eventListeners.has('>')) {
+                    const wildcardListeners = this.eventListeners.get('>');
+                    wildcardListeners.forEach(callback => {
+                        try {
+                            // 将事件名也传递给通配符监听器
+                            callback({ ...data, event });
+                        } catch (e) {
+                            console.error('[KernelClient] Wildcard event listener error:', e);
+                        }
+                    });
+                }
+            }
+        } catch (e) {
+            console.error('[KernelClient] Message parse error:', e);
+        }
+    }
+
+    /**
+     * 内部：安排重连
+     */
+    _scheduleReconnect() {
+        if (this.reconnectTimer) return;
+
+        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');
+            if (this.onConnectionChange) {
+                this.onConnectionChange('error', '连接失败（永久性错误）');
+            }
+            return;
+        }
+
+        // 如果已经标记为 fatalError，不再重连
+        if (this.fatalError) {
+            console.error('[KernelClient] Fatal error detected, reconnection disabled');
+            if (this.onConnectionChange) {
+                this.onConnectionChange('error', '连接失败（永久性错误）');
+            }
+            return;
+        }
+
+        let delay;
+
+        // 4050: Kernel 不可用 — 使用服务端建议的延迟
+        if (code === 4050 && this._serverRetryAfterMs > 0) {
+            delay = this._serverRetryAfterMs;
+            const ks = this._lastKernelStatus;
+            const stateDesc = ks ? `${ks.state} ${ks.attempt}/${ks.max_attempts}` : 'unknown';
+            console.log(`[KernelClient] Kernel unavailable (${stateDesc}), server suggests retry in ${delay}ms`);
+            this._serverRetryAfterMs = 0;  // 用完清除，下次回退到 standard
+        }
+        // cooldown: 速率限制
+        else if (code === 4020) {
+            this.cooldownAttempts++;
+            if (this.cooldownAttempts >= 5) {
+                this.fatalError = true;
+                console.error('[KernelClient] Rate limit exceeded, reconnection disabled');
+                if (this.onConnectionChange) {
+                    this.onConnectionChange('error', '速率限制，停止重连');
+                }
+                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})`);
+        }
+
+        // 通知正在重连（附带服务端状态）
+        if (this.onConnectionChange) {
+            const ks = this._lastKernelStatus;
+            const detail = ks ? `Kernel ${ks.state} ${ks.attempt}/${ks.max_attempts}` : '';
+            this.onConnectionChange('reconnecting', `正在重连... ${detail} (${Math.round(delay / 1000)}s后)`);
+        }
+
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch(err => {
+                console.error('[KernelClient] Reconnect failed:', err);
+            });
+        }, delay);
+    }
+
+    /**
+     * 内部：生成随机字符串
+     */
+    _randomString(length) {
+        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+}
+
+// 导出
+window.KernelClient = KernelClient;

package/extensions/services/{evol/static/js/kernel-client.js → kite_console/static/js/kernel-client.js.backup}

@@ -25,9 +25,16 @@ class KernelClient {
         // 事件监听器
         this.eventListeners = new Map(); // event -> [callbacks]
 
+        // 连接状态回调
+        this.onConnectionChange = null; // (status, message) => void
+        // status: 'connected' | 'disconnected' | 'reconnecting' | 'error'
+
+        // 认证成功回调（在认证完成后触发，用于重新订阅事件等）
+        this.onAuthenticated = null; // (reconnected: boolean) => void
+
         // 重连配置
         this.reconnectDelay = 1000; // 1秒
-        this.maxReconnectDelay = 10000; // 10秒
+        this.maxReconnectDelay = 30000; // 30秒
         this.reconnectAttempts = 0;
         this.reconnectTimer = null;
         this.fatalError = false; // 是否遇到永久性错误（不应重试）
@@ -37,7 +44,8 @@ class KernelClient {
         this.heartbeatTimer = null;
 
         // Token 管理
-        this.token = localStorage.getItem('frontend_token');
+        // 优先使用 kiteToken（Evol 业务），其次使用 frontend_token（配对码）
+        this.token = localStorage.getItem('kiteToken') || localStorage.getItem('frontend_token');
         this.sessionToken = sessionStorage.getItem('session_token');
 
         // 生成 session_token（如果没有）
@@ -120,10 +128,21 @@ class KernelClient {
                         this.authenticated = true;
 
                         ws.removeEventListener('message', handler);
+
+                        // 触发认证成功回调
+                        const isReconnected = msg.type === 'reconnected';
+                        if (this.onAuthenticated) {
+                            try {
+                                this.onAuthenticated(isReconnected);
+                            } catch (e) {
+                                console.error('[KernelClient] onAuthenticated callback error:', e);
+                            }
+                        }
+
                         resolve({
                             moduleId: this.moduleId,
                             role: this.role,
-                            reconnected: msg.type === 'reconnected'
+                            reconnected: isReconnected
                         });
                     } else if (msg.type === 'error') {
                         // 认证失败
@@ -282,6 +301,12 @@ class KernelClient {
             this.reconnectAttempts = 0;
             this.reconnectDelay = 1000;
             this._startHeartbeat();
+
+            // 通知连接状态变化
+            if (this.onConnectionChange) {
+                this.onConnectionChange('connected', 'WebSocket 已连接');
+            }
+
             onOpen(ws);
         };
 
@@ -297,6 +322,11 @@ class KernelClient {
             this.ws = null;
             this._stopHeartbeat();
 
+            // 通知连接状态变化
+            if (this.onConnectionChange) {
+                this.onConnectionChange('disconnected', 'WebSocket 已断开');
+            }
+
             // 自动重连（如果有 token）
             if (this.token) {
                 this._scheduleReconnect();
@@ -358,6 +388,9 @@ class KernelClient {
         // 如果遇到永久性错误，不再重连
         if (this.fatalError) {
             console.error('[KernelClient] Fatal error detected, reconnection disabled');
+            if (this.onConnectionChange) {
+                this.onConnectionChange('error', '连接失败（永久性错误）');
+            }
             return;
         }
 
@@ -371,6 +404,11 @@ class KernelClient {
 
         console.log(`[KernelClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
 
+        // 通知正在重连
+        if (this.onConnectionChange) {
+            this.onConnectionChange('reconnecting', `正在重连... (${this.reconnectAttempts})`);
+        }
+
         this.reconnectTimer = setTimeout(() => {
             this.reconnectTimer = null;
             this.connect().catch(err => {

package/extensions/services/{evol → kite_console}/static/js/registry-tests.js

@@ -132,8 +132,12 @@ async function runAllTests() {
 
     try {
         // 等待 kernelClient 连接和认证
+        // 使用全局的 app.kernelClient
+        const kernelClient = window.app?.kernelClient;
+
         if (!kernelClient) {
             logTest('错误: kernelClient 未初始化', 'fail');
+            logTest('  请确保 evol-app.js 已加载并初始化', 'info');
             return;
         }
 
@@ -158,6 +162,9 @@ async function runAllTests() {
             logTest('', 'info');
         }
 
+        // 将 kernelClient 设置为全局变量，供测试函数使用
+        window.kernelClient = kernelClient;
+
         // 1. 核心功能测试
         await testRegistryCore();