@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/kite_console/static/js/tests/modules/acp_channel.js

@@ -0,0 +1,339 @@
+/**
+ * ACP Channel 模块完整生命周期测试
+ * 测试启动阶段、运行阶段、退出阶段的完整流程
+ */
+
+async function testAcpChannelModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【ACP Channel 模块生命周期测试】', 'section');
+
+  // ========== 第一阶段：启动验证 ==========
+  runner.log('', 'info');
+  runner.log('第一阶段：启动验证', 'subsection');
+
+  let moduleExists = false;
+  let moduleRunning = false;
+
+  await runner.runTest('模块存在性检查', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const module = result.modules.find(m => m.name === 'acp_channel');
+    if (!module) throw new Error('acp_channel 模块不存在');
+    moduleExists = true;
+    moduleRunning = module.actual_state && module.actual_state.startsWith('running');
+    runner.log(`  模块状态: ${module.actual_state}`, 'info');
+  });
+
+  if (!moduleExists) {
+    runner.log('', 'info');
+    runner.log('⚠ 模块不存在，跳过后续测试', 'skip');
+    return;
+  }
+
+  if (!moduleRunning) {
+    runner.log('', 'info');
+    runner.log('⚠ 模块未运行，跳过后续测试', 'skip');
+    return;
+  }
+
+  await runner.runTest('模块注册信息检查', async () => {
+    const result = await client.call('registry.list', {});
+    const module = result.modules.find(m => m.module_id === 'acp_channel');
+    if (!module) throw new Error('模块未在注册中心注册');
+    if (!module.tools || !module.tools.rpc) throw new Error('缺少 RPC 方法注册');
+    if (!module.events_publish) throw new Error('缺少事件发布注册');
+    const rpcMethods = Object.keys(module.tools.rpc.module || {}).map(m => `acp_channel.${m}`);
+    runner.log(`  注册的 RPC 方法: ${rpcMethods.join(', ')}`, 'info');
+    runner.log(`  注册的事件: ${Object.keys(module.events_publish).map(k => Object.keys(module.events_publish[k]).map(e => `${k}.${e}`)).flat().join(', ')}`, 'info');
+  });
+
+  // ========== 第二阶段：RPC 方法注册验证 ==========
+  runner.log('', 'info');
+  runner.log('第二阶段：RPC 方法注册验证', 'subsection');
+
+  const rpcMethods = ['acp_channel.echo', 'acp_channel.get_status'];
+
+  for (const method of rpcMethods) {
+    await runner.runTest(`${method} 注册检查`, async () => {
+      const result = await client.call('registry.lookup', {
+        field: `tools.rpc.module.${method.split('.')[1]}`,
+        module: 'acp_channel'
+      });
+      if (!result.results || result.results.length === 0) {
+        throw new Error('RPC 方法未注册');
+      }
+    });
+  }
+
+  // ========== 第三阶段：事件注册验证 ==========
+  runner.log('', 'info');
+  runner.log('第三阶段：事件注册验证', 'subsection');
+
+  await runner.runTest('acp_channel.test 事件注册', async () => {
+    const result = await client.call('registry.lookup', {
+      field: 'events_publish.acp_channel.test',
+      module: 'acp_channel'
+    });
+    if (!result.results || result.results.length === 0) {
+      throw new Error('事件未注册');
+    }
+  });
+
+  // ========== 第四阶段：RPC 方法调用测试（单次） ==========
+  runner.log('', 'info');
+  runner.log('第四阶段：RPC 方法调用测试（单次）', 'subsection');
+
+  await runner.runTest('acp_channel.echo 单次调用', async () => {
+    const testMessage = 'Hello from test suite';
+    const result = await client.call('acp_channel.echo', { message: testMessage });
+    if (!result.echo || result.echo !== testMessage) {
+      throw new Error(`返回值不匹配: ${result.echo}`);
+    }
+    if (!result.timestamp) throw new Error('缺少 timestamp 字段');
+    runner.log(`  返回: ${JSON.stringify(result)}`, 'info');
+  });
+
+  await runner.runTest('acp_channel.get_status 单次调用', async () => {
+    const result = await client.call('acp_channel.get_status', {});
+    if (!result.status) throw new Error('缺少 status 字段');
+    if (result.module_id !== 'acp_channel') throw new Error('module_id 不匹配');
+    if (typeof result.uptime !== 'number') throw new Error('缺少 uptime 字段');
+    runner.log(`  运行时长: ${result.uptime.toFixed(2)}s`, 'info');
+  });
+
+  // ========== 第五阶段：RPC 方法多次调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第五阶段：RPC 方法多次调用测试（10次）', 'subsection');
+
+  await runner.runTest('acp_channel.echo 多次调用', async () => {
+    const iterations = 10;
+    for (let i = 0; i < iterations; i++) {
+      const result = await client.call('rpc.call', {
+        target: 'acp_channel',
+        method: 'acp_channel.echo',
+        params: { message: `Test ${i + 1}` }
+      });
+      if (!result.echo || result.echo !== `Test ${i + 1}`) {
+        throw new Error(`第 ${i + 1} 次调用失败`);
+      }
+    }
+    runner.log(`  成功完成 ${iterations} 次调用`, 'info');
+  });
+
+  // ========== 第六阶段：RPC 方法并发调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第六阶段：RPC 方法并发调用测试（10个并发）', 'subsection');
+
+  await runner.runTest('acp_channel.echo 并发调用', async () => {
+    const concurrency = 10;
+    const promises = [];
+    for (let i = 0; i < concurrency; i++) {
+      promises.push(
+        client.call('rpc.call', {
+          target: 'acp_channel',
+          method: 'acp_channel.echo',
+          params: { message: `Concurrent ${i + 1}` }
+        })
+      );
+    }
+    const results = await Promise.all(promises);
+    for (let i = 0; i < concurrency; i++) {
+      if (!results[i].echo || results[i].echo !== `Concurrent ${i + 1}`) {
+        throw new Error(`并发调用 ${i + 1} 失败`);
+      }
+    }
+    runner.log(`  成功完成 ${concurrency} 个并发调用`, 'info');
+  });
+
+  // ========== 第七阶段：跨模块 RPC 调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第七阶段：跨模块 RPC 调用测试', 'subsection');
+
+  // 测试 acp_channel 调用其他模块的 RPC
+  await runner.runTest('调用 kernel.health', async () => {
+    const result = await client.call('kernel.health', {});
+    if (!result.status) throw new Error('kernel.health 调用失败');
+    runner.log(`  Kernel 状态: ${result.status}`, 'info');
+  });
+
+  await runner.runTest('调用 launcher.list_modules', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules) throw new Error('launcher.list_modules 调用失败');
+    runner.log(`  模块数量: ${result.modules.length}`, 'info');
+  });
+
+  // ========== 第八阶段：Ping-Pong 机制测试 ==========
+  runner.log('', 'info');
+  runner.log('第八阶段：Ping-Pong 机制测试', 'subsection');
+
+  await runner.runTest('订阅 system.pong 事件', async () => {
+    await client.subscribe(['system.pong']);
+  });
+
+  await runner.runTest('发送 system.ping 并接收 pong', async () => {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        client.off('event', handler);
+        reject(new Error('5秒内未收到 pong 响应'));
+      }, 5000);
+
+      const handler = (event) => {
+        if (event.event === 'system.pong' && event.data.module_id === 'acp_channel') {
+          clearTimeout(timeout);
+          client.off('event', handler);
+          const latency = (event.data.pong_time - event.data.ping_time) * 1000;
+          runner.log(`  Ping 延迟: ${latency.toFixed(2)}ms`, 'info');
+          resolve();
+        }
+      };
+
+      client.on('event', handler);
+
+      // 发送 ping 事件
+      client.call('event.publish', {
+        event_id: Math.random().toString(36).substring(7),
+        event: 'system.ping',
+        data: { ping_time: Date.now() / 1000 }
+      });
+    });
+  });
+
+  // ========== 第九阶段：事件订阅和接收测试 ==========
+  runner.log('', 'info');
+  runner.log('第九阶段：事件订阅和接收测试', 'subsection');
+
+  await runner.runTest('订阅 acp_channel.test 事件', async () => {
+    await client.subscribe(['acp_channel.test']);
+  });
+
+  await runner.runTest('接收 acp_channel.test 事件', async () => {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        client.off('event', handler);
+        reject(new Error('15秒内未收到测试事件'));
+      }, 15000);
+
+      const handler = (event) => {
+        if (event.event === 'acp_channel.test') {
+          clearTimeout(timeout);
+          client.off('event', handler);
+          if (!event.data || !event.data.message) {
+            reject(new Error('事件数据格式不正确'));
+          } else {
+            runner.log(`  收到事件: ${event.data.message}`, 'info');
+            resolve();
+          }
+        }
+      };
+
+      client.on('event', handler);
+    });
+  });
+
+  // ========== 第十阶段：错误处理测试 ==========
+  runner.log('', 'info');
+  runner.log('第十阶段：错误处理测试', 'subsection');
+
+  await runner.runTest('调用不存在的 RPC 方法', async () => {
+    try {
+      await client.call('acp_channel.nonexistent', {});
+      throw new Error('应该抛出错误但没有');
+    } catch (err) {
+      if (err.message.includes('应该抛出错误')) throw err;
+      runner.log(`  正确捕获错误: ${err.message}`, 'info');
+    }
+  });
+
+  await runner.runTest('调用 RPC 时传递错误参数', async () => {
+    try {
+      await client.call('acp_channel.echo', { wrong_param: 'test' });
+      // echo 方法可能不会因为缺少参数而失败，所以这里只是验证调用能完成
+      runner.log(`  方法容错性良好`, 'info');
+    } catch (err) {
+      runner.log(`  捕获到错误: ${err.message}`, 'info');
+    }
+  });
+
+  // ========== 第十一阶段：优雅退出流程测试 ==========
+  runner.log('', 'info');
+  runner.log('第十一阶段：优雅退出流程测试', 'subsection');
+
+  await runner.runTest('订阅 shutdown 相关事件', async () => {
+    await client.subscribe([
+      'module.shutdown.ack',
+      'module.shutdown.ready',
+      'module.stopped',
+      'module.exiting'
+    ]);
+  });
+
+  await runner.runTest('发送 shutdown 信号并验证事件时序', async () => {
+    return new Promise((resolve, reject) => {
+      const receivedEvents = [];
+      const expectedSequence = ['module.shutdown.ack', 'module.shutdown.ready'];
+      let timeout;
+
+      const handler = (event) => {
+        if (event.data && event.data.module_id === 'acp_channel') {
+          receivedEvents.push(event.event);
+          runner.log(`  收到事件: ${event.event}`, 'info');
+
+          // 检查是否收到了所有预期事件
+          if (receivedEvents.includes('module.shutdown.ack') &&
+              receivedEvents.includes('module.shutdown.ready')) {
+            clearTimeout(timeout);
+            client.off('event', handler);
+
+            // 验证事件顺序
+            const ackIndex = receivedEvents.indexOf('module.shutdown.ack');
+            const readyIndex = receivedEvents.indexOf('module.shutdown.ready');
+
+            if (ackIndex < readyIndex) {
+              runner.log(`  事件时序正确: ack → ready`, 'info');
+              resolve();
+            } else {
+              reject(new Error(`事件时序错误: ${receivedEvents.join(' → ')}`));
+            }
+          }
+        }
+      };
+
+      timeout = setTimeout(() => {
+        client.off('event', handler);
+        reject(new Error(`10秒内未收到完整的 shutdown 事件序列，已收到: ${receivedEvents.join(', ')}`));
+      }, 10000);
+
+      client.on('event', handler);
+
+      // 发送 shutdown 信号
+      client.call('event.publish', {
+        event_id: Math.random().toString(36).substring(7),
+        event: 'module.shutdown',
+        data: { module_id: 'acp_channel', reason: 'test' }
+      }).catch(err => {
+        clearTimeout(timeout);
+        client.off('event', handler);
+        reject(new Error(`发送 shutdown 信号失败: ${err.message}`));
+      });
+    });
+  });
+
+  // 等待模块重启
+  runner.log('', 'info');
+  runner.log('等待模块自动重启...', 'info');
+  await new Promise(resolve => setTimeout(resolve, 3000));
+
+  await runner.runTest('验证模块已重新启动', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const module = result.modules.find(m => m.name === 'acp_channel');
+    if (!module) throw new Error('模块未找到');
+    const running = module.actual_state && module.actual_state.startsWith('running');
+    if (!running) throw new Error(`模块未重启，状态: ${module.actual_state}`);
+    runner.log(`  模块状态: ${module.actual_state}`, 'info');
+  });
+
+  runner.log('');
+}
+
+window.testAcpChannelModule = testAcpChannelModule;

package/extensions/services/kite_console/static/js/tests/modules/auth.js

@@ -0,0 +1,96 @@
+/**
+ * Auth 模块测试
+ */
+
+async function testAuthModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Auth 模块测试】', 'section');
+
+  // RPC 方法测试
+  runner.log('RPC 方法调用测试', 'subsection');
+
+  await runner.runTest('auth.get_supported_methods', async () => {
+    const result = await client.call('auth.get_supported_methods', {});
+    if (!result.methods || !Array.isArray(result.methods)) throw new Error('缺少 methods 数组');
+    if (!result.methods.includes('pairing_code')) throw new Error('缺少 pairing_code 方法');
+    if (!result.methods.includes('kite_token')) throw new Error('缺少 kite_token 方法');
+  });
+
+  await runner.runTest('auth.request_pairing_code 返回不含 code', async () => {
+    const result = await client.call('auth.request_pairing_code', { role: 'admin' });
+    if (result.status !== 'generated') throw new Error(`期望 status=generated，实际: ${result.status}`);
+    if (typeof result.ttl !== 'number') throw new Error('缺少 ttl 字段');
+    if (result.code !== undefined) throw new Error('响应不应包含 code 字段');
+  });
+
+  await runner.runTest('auth.get_pending_codes', async () => {
+    const result = await client.call('auth.get_pending_codes', {});
+    if (!Array.isArray(result.codes)) throw new Error('缺少 codes 数组');
+    if (typeof result.count !== 'number') throw new Error('缺少 count 字段');
+    if (result.count < 1) throw new Error('应至少有 1 个待验证配对码');
+  });
+
+  await runner.runTest('auth.list_tokens', async () => {
+    const result = await client.call('auth.list_tokens', {});
+    if (!Array.isArray(result.tokens)) throw new Error('缺少 tokens 数组');
+    if (typeof result.count !== 'number') throw new Error('缺少 count 字段');
+  });
+
+  await runner.runTest('auth.revoke_token 参数缺失返回错误', async () => {
+    const result = await client.call('auth.revoke_token', {});
+    if (result.success !== false) throw new Error('缺少参数应返回 success=false');
+    if (!result.error) throw new Error('缺少 error 字段');
+  });
+
+  await runner.runTest('auth.health', async () => {
+    const result = await client.call('auth.health', {});
+    if (result.status !== 'healthy') throw new Error(`期望 healthy，实际: ${result.status}`);
+  });
+
+  await runner.runTest('auth.status', async () => {
+    const result = await client.call('auth.status', {});
+    if (result.module !== 'auth') throw new Error(`期望 module=auth，实际: ${result.module}`);
+  });
+
+  // 注册中心验证
+  runner.log('', 'info');
+  runner.log('注册中心 RPC 注册验证', 'subsection');
+
+  await runner.runTest('Auth RPC tools 注册检查', async () => {
+    const result = await client.call('registry.get', { path: 'auth.tools.rpc.auth' });
+    const rpcTools = result.value;
+    if (!rpcTools) throw new Error('auth RPC tools 未注册');
+    const expected = ['verify', 'request_pairing_code', 'list_tokens', 'revoke_token', 'get_supported_methods', 'get_pending_codes'];
+    for (const method of expected) {
+      if (!rpcTools[method]) throw new Error(`缺少 RPC 方法注册: ${method}`);
+    }
+  });
+
+  // 事件注册验证
+  runner.log('', 'info');
+  runner.log('事件注册验证', 'subsection');
+
+  await runner.runTest('Auth 事件发布注册检查', async () => {
+    const result = await client.call('registry.get', { path: 'auth.events_publish.auth' });
+    const events = result.value;
+    if (!events) throw new Error('auth 事件发布未注册');
+    const expected = ['success', 'failed', 'code_generated', 'token.created', 'token.revoked'];
+    for (const evt of expected) {
+      if (!events[evt]) throw new Error(`缺少事件注册: auth.${evt}`);
+    }
+  });
+
+  await runner.runTest('Auth 事件订阅注册检查', async () => {
+    const result = await client.call('registry.get', { path: 'auth.events_subscribe' });
+    const subs = result.value;
+    if (!Array.isArray(subs)) throw new Error('events_subscribe 应为数组');
+    if (!subs.includes('module.ready')) throw new Error('缺少 module.ready 订阅');
+    if (!subs.includes('module.shutdown')) throw new Error('缺少 module.shutdown 订阅');
+  });
+
+  runner.log('');
+}
+
+window.testAuthModule = testAuthModule;

package/extensions/services/kite_console/static/js/tests/modules/backup.js

@@ -0,0 +1,49 @@
+/**
+ * Backup 模块测试
+ */
+
+async function testBackupModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Backup 模块测试】', 'section');
+
+  // 模块存在性检查
+  await runner.runTest('Backup 模块存在性检查', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const backup = result.modules.find(m => m.name === 'backup');
+    if (!backup) throw new Error('Backup 模块未找到');
+  });
+
+  // RPC 方法注册验证
+  runner.log('', 'info');
+  runner.log('RPC 方法注册验证', 'subsection');
+
+  const rpcMethods = ['health', 'status'];
+
+  for (const method of rpcMethods) {
+    await runner.runTest(`backup.${method} 注册检查`, async () => {
+      const result = await client.call('registry.lookup', {
+        field: `tools.rpc.module.${method}`,
+        module: 'backup'
+      });
+      if (!result.results || result.results.length === 0) throw new Error('未找到注册');
+    });
+  }
+
+  // 事件注册验证
+  runner.log('', 'info');
+  runner.log('事件注册验证', 'subsection');
+
+  await runner.runTest('backup.test 事件注册', async () => {
+    const result = await client.call('registry.lookup', {
+      field: 'events_publish.backup.test',
+      module: 'backup'
+    });
+    if (!result.results || result.results.length === 0) throw new Error('事件未注册');
+  });
+
+  runner.log('');
+}
+
+window.testBackupModule = testBackupModule;

package/extensions/services/kite_console/static/js/tests/modules/gateway.js

@@ -0,0 +1,41 @@
+/**
+ * Gateway 模块测试
+ */
+
+async function testGatewayModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Gateway 模块测试】', 'section');
+
+  // 注册中心注册检查
+  runner.log('注册中心注册检查', 'subsection');
+
+  await runner.runTest('Gateway 注册信息检查', async () => {
+    const result = await client.call('registry.get', { path: 'gateway.base_url' });
+    const baseUrl = result.value;
+    if (!baseUrl) throw new Error('gateway base_url 未注册');
+    if (!baseUrl.startsWith('ws://')) throw new Error(`base_url 应以 ws:// 开头，实际: ${baseUrl}`);
+  });
+
+  // RPC 方法测试
+  runner.log('', 'info');
+  runner.log('RPC 方法调用测试', 'subsection');
+
+  await runner.runTest('gateway.health', async () => {
+    const result = await client.call('gateway.health', {});
+    if (result.status !== 'healthy') throw new Error(`期望 healthy，实际: ${result.status}`);
+    if (!result.details) throw new Error('缺少 details 字段');
+    if (typeof result.details.active_sessions !== 'number') throw new Error('缺少 active_sessions');
+  });
+
+  await runner.runTest('gateway.status', async () => {
+    const result = await client.call('gateway.status', {});
+    if (result.module !== 'gateway') throw new Error(`期望 module=gateway，实际: ${result.module}`);
+    if (result.status !== 'running') throw new Error(`期望 status=running，实际: ${result.status}`);
+  });
+
+  runner.log('');
+}
+
+window.testGatewayModule = testGatewayModule;

package/extensions/services/kite_console/static/js/tests/modules/kernel.js

@@ -0,0 +1,90 @@
+/**
+ * Kernel 模块测试
+ */
+
+async function testKernelModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Kernel 模块测试】', 'section');
+
+  // RPC 方法测试
+  runner.log('RPC 方法调用测试', 'subsection');
+
+  await runner.runTest('Kernel.health', async () => {
+    const result = await client.call('kernel.health', {});
+    if (!result.event_stats) throw new Error('缺少 event_stats 字段');
+    if (typeof result.status !== 'string') throw new Error('缺少 status 字段');
+  });
+
+  await runner.runTest('Kernel.stats', async () => {
+    const result = await client.call('kernel.stats', {});
+    if (!result.counters) throw new Error('缺少 counters 字段');
+    if (!result.rpc) throw new Error('缺少 rpc 字段');
+  });
+
+  await runner.runTest('Kernel.get_registry_stats', async () => {
+    const result = await client.call('kernel.get_registry_stats', {});
+    if (result.total_records === undefined) throw new Error('缺少 total_records 字段');
+  });
+
+  await runner.runTest('Kernel.ping', async () => {
+    try {
+      const result = await client.call('kernel.ping', {});
+      if (result.status !== 'ok') throw new Error('Ping 失败');
+    } catch (err) {
+      // kernel.ping 可能需要特殊权限，跳过此测试
+      if (err.message.includes('Permission denied')) {
+        runner.skip('Kernel.ping (权限不足)');
+        return;
+      }
+      throw err;
+    }
+  });
+
+  // 注册中心方法测试
+  runner.log('', 'info');
+  runner.log('注册中心方法测试', 'subsection');
+
+  await runner.runTest('registry.lookup', async () => {
+    const result = await client.call('registry.lookup', {});
+    if (!result.results || !Array.isArray(result.results)) throw new Error('返回格式错误');
+  });
+
+  await runner.runTest('registry.get', async () => {
+    const result = await client.call('registry.get', { path: 'kernel.module_id' });
+    if (result.value !== 'kernel') throw new Error('查询结果不正确');
+  });
+
+  // 事件测试
+  runner.log('', 'info');
+  runner.log('事件测试', 'subsection');
+
+  await runner.runTest('Kernel 事件订阅', async () => {
+    try {
+      await client.subscribe(['kernel.module_registered']);
+      // 订阅成功（没有抛出异常）
+    } catch (err) {
+      throw new Error(`事件订阅失败: ${err.message}`);
+    }
+  });
+
+  // 链路追踪测试
+  runner.log('', 'info');
+  runner.log('链路追踪测试', 'subsection');
+
+  await runner.runTest('trace.list', async () => {
+    const result = await client.call('trace.list', { limit: 10 });
+    if (!result.traces || !Array.isArray(result.traces)) throw new Error('返回格式错误');
+    if (typeof result.total !== 'number') throw new Error('缺少 total 字段');
+  });
+
+  await runner.runTest('trace.query (不存在的 trace_id)', async () => {
+    const result = await client.call('trace.query', { trace_id: 'non-existent-trace-id' });
+    if (result.found !== false) throw new Error('应该返回 found: false');
+  });
+
+  runner.log('');
+}
+
+window.testKernelModule = testKernelModule;