@agentunion/kite 1.3.1 → 1.4.0

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

@@ -0,0 +1,161 @@
+/**
+ * Kernel Client 使用示例
+ *
+ * 在主页面（index.html）中集成 KernelClient
+ */
+
+// 全局 Kernel 客户端实例
+let kernelClient = null;
+
+/**
+ * 初始化 Kernel 客户端
+ */
+async function initKernelClient() {
+    const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+    kernelClient = new KernelClient(`${proto}//${location.host}/ws/relay`);
+
+    // 检查是否已配对
+    const token = localStorage.getItem('frontend_token');
+
+    if (!token) {
+        // 未配对，跳转到配对页面
+        window.location.href = '/pairing.html';
+        return;
+    }
+
+    try {
+        // 连接
+        const result = await kernelClient.connect();
+        console.log('[Kernel] Connected:', result);
+
+        // 订阅事件
+        await kernelClient.subscribe([
+            'module.starting',
+            'module.started',
+            'module.ready',
+            'module.stopped',
+            'module.exiting',
+            'module.shutdown',
+            'module.crashed',
+            'system.ready',
+            'registry.updated',
+            'module.registered',
+            'module.unregistered'
+        ]);
+
+        // 监听模块状态变化
+        kernelClient.on('module.started', (data) => {
+            console.log('[Kernel] Module started:', data.module_id);
+            updateModuleStatus(data.module_id, 'running');
+        });
+
+        kernelClient.on('module.stopped', (data) => {
+            console.log('[Kernel] Module stopped:', data.module_id);
+            updateModuleStatus(data.module_id, 'stopped');
+        });
+
+        kernelClient.on('module.crashed', (data) => {
+            console.log('[Kernel] Module crashed:', data.module_id);
+            updateModuleStatus(data.module_id, 'crashed');
+        });
+
+        kernelClient.on('registry.updated', (data) => {
+            console.log('[Kernel] Registry updated:', data);
+            // 触发缓存失效事件
+            window.dispatchEvent(new CustomEvent('registryCacheInvalidate', {
+                detail: data
+            }));
+        });
+
+        // 更新连接状态指示器
+        updateConnectionStatus(true);
+
+        // 触发连接成功事件
+        window.dispatchEvent(new CustomEvent('kernelClientReady'));
+
+    } catch (err) {
+        console.error('[Kernel] Connection failed:', err);
+
+        // 如果是 token 无效，跳转到配对页面
+        if (err.message.includes('Invalid') || err.message.includes('expired')) {
+            window.location.href = '/pairing.html';
+        } else {
+            updateConnectionStatus(false);
+        }
+    }
+}
+
+/**
+ * 更新连接状态指示器
+ */
+function updateConnectionStatus(connected) {
+    const indicators = [
+        document.getElementById('ws-indicator'),
+        document.getElementById('ws-indicator-modules')
+    ];
+
+    indicators.forEach(indicator => {
+        if (indicator) {
+            if (connected) {
+                indicator.textContent = '● 已连线';
+                indicator.style.color = 'var(--success)';
+            } else {
+                indicator.textContent = '○ 未连线';
+                indicator.style.color = 'var(--gray-400)';
+            }
+        }
+    });
+}
+
+/**
+ * 更新模块状态
+ */
+function updateModuleStatus(moduleName, status) {
+    // 这里调用现有的模块状态更新逻辑
+    if (typeof _onModuleStatusChange === 'function') {
+        _onModuleStatusChange(moduleName, status);
+    }
+}
+
+/**
+ * 调用 RPC 示例
+ */
+async function exampleRpcCalls() {
+    if (!kernelClient) {
+        console.error('[Kernel] Client not initialized');
+        return;
+    }
+
+    try {
+        // 获取模块列表
+        const modules = await kernelClient.call('launcher.list_modules');
+        console.log('[Kernel] Modules:', modules);
+
+        // 启动模块
+        await kernelClient.call('launcher.start_module', { name: 'watchdog' });
+        console.log('[Kernel] Module started');
+
+        // 停止模块
+        await kernelClient.call('launcher.stop_module', { name: 'watchdog' });
+        console.log('[Kernel] Module stopped');
+
+    } catch (err) {
+        console.error('[Kernel] RPC error:', err);
+    }
+}
+
+/**
+ * 页面加载时初始化
+ */
+document.addEventListener('DOMContentLoaded', () => {
+    initKernelClient();
+});
+
+/**
+ * 页面关闭时断开连接
+ */
+window.addEventListener('beforeunload', () => {
+    if (kernelClient) {
+        kernelClient.disconnect();
+    }
+});

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

@@ -0,0 +1,383 @@
+/**
+ * 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.reconnectDelay = 1000; // 1秒
+        this.maxReconnectDelay = 10000; // 10秒
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+
+        // 心跳配置
+        this.heartbeatInterval = 20000; // 20秒
+        this.heartbeatTimer = null;
+
+        // Token 管理
+        this.token = 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);
+        }
+    }
+
+    /**
+     * 配对（首次使用）
+     */
+    async pair(code) {
+        return new Promise((resolve, reject) => {
+            this._connect((ws) => {
+                // 发送配对消息
+                ws.send(JSON.stringify({
+                    type: 'pair',
+                    code: code
+                }));
+
+                // 等待响应
+                const handler = (event) => {
+                    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) => {
+                // 发送认证消息
+                ws.send(JSON.stringify({
+                    type: 'auth',
+                    token: this.token,
+                    session_token: this.sessionToken
+                }));
+
+                // 等待响应
+                const handler = (event) => {
+                    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);
+                        resolve({
+                            moduleId: this.moduleId,
+                            role: this.role,
+                            reconnected: msg.type === 'reconnected'
+                        });
+                    } else if (msg.type === 'error') {
+                        // 认证失败
+                        ws.removeEventListener('message', handler);
+
+                        // 如果是 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 请求
+            this.ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                id: id,
+                method: method,
+                params: params
+            }));
+
+            // 设置超时
+            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 {
+                this.ws.send(JSON.stringify({ type: 'disconnect' }));
+            } 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 消息
+                    this.ws.send(JSON.stringify({ type: 'ping' }));
+                } 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;
+        }
+
+        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._startHeartbeat();
+            onOpen(ws);
+        };
+
+        ws.onerror = (error) => {
+            console.error('[KernelClient] WebSocket error:', error);
+            if (onError) onError(error);
+        };
+
+        ws.onclose = () => {
+            console.log('[KernelClient] WebSocket closed');
+            this.connected = false;
+            this.authenticated = false;
+            this.ws = null;
+            this._stopHeartbeat();
+
+            // 自动重连（如果有 token）
+            if (this.token) {
+                this._scheduleReconnect();
+            }
+        };
+
+        ws.onmessage = (event) => {
+            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);
+                        }
+                    });
+                }
+            }
+        } catch (e) {
+            console.error('[KernelClient] Message parse error:', e);
+        }
+    }
+
+    /**
+     * 内部：安排重连
+     */
+    _scheduleReconnect() {
+        if (this.reconnectTimer) return;
+
+        this.reconnectAttempts++;
+        const delay = Math.min(
+            this.reconnectDelay * Math.pow(1.5, this.reconnectAttempts - 1),
+            this.maxReconnectDelay
+        );
+
+        console.log(`[KernelClient] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+
+        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;