@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/kite_console/static/js/tests/integration/require-init.js

@@ -0,0 +1,96 @@
+/**
+ * system.require_init 流程集成测试
+ *
+ * 验证：
+ * 1. 新 WS 连接 auth 后收到 system.require_init
+ * 2. 模块注册后 registry.lookup 可查到
+ * 3. 所有模块 status 为 ready（启动流程完整性）
+ */
+
+async function testRequireInit() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【system.require_init 流程测试】', 'section');
+
+  // 1. 验证所有模块已注册（新启动流程完整性）
+  await runner.runTest('所有模块已注册', async () => {
+    const result = await client.call('registry.lookup', {});
+    if (!result.results || result.results.length === 0) {
+      throw new Error('registry.lookup 返回空列表');
+    }
+    runner.log(`  已注册模块数: ${result.results.length}`, 'info');
+  });
+
+  // 2. 验证 Kernel 和 Launcher 已注册
+  await runner.runTest('Kernel 已注册', async () => {
+    const result = await client.call('registry.lookup', { module: 'kernel' });
+    if (!result.results || result.results.length === 0) {
+      throw new Error('kernel 模块未注册');
+    }
+  });
+
+  await runner.runTest('Launcher 已注册', async () => {
+    const result = await client.call('registry.lookup', { module: 'launcher' });
+    if (!result.results || result.results.length === 0) {
+      throw new Error('launcher 模块未注册');
+    }
+  });
+
+  // 3. 验证模块状态为 ready
+  await runner.runTest('模块状态检查', async () => {
+    const modules = await client.call('launcher.list_modules', {});
+    if (!modules.modules) throw new Error('无法获取模块列表');
+
+    const running = modules.modules.filter(m =>
+      m.actual_state && m.actual_state.startsWith('running')
+    );
+    runner.log(`  运行中模块数: ${running.length}`, 'info');
+
+    // 每个运行中的模块应该在 registry 中有记录
+    for (const mod of running) {
+      const reg = await client.call('registry.lookup', { module: mod.name });
+      if (!reg.results || reg.results.length === 0) {
+        throw new Error(`运行中的模块 '${mod.name}' 未在 registry 中注册`);
+      }
+    }
+  });
+
+  // 4. 验证 Watchdog RPC 方法已注册（通过 require_init 流程注册的）
+  await runner.runTest('Watchdog RPC 注册验证', async () => {
+    const result = await client.call('registry.lookup', {
+      field: 'tools.rpc.module.start_monitor',
+      module: 'watchdog',
+    });
+    if (!result.results || result.results.length === 0) {
+      throw new Error('watchdog.start_monitor 未注册（require_init 流程可能失败）');
+    }
+  });
+
+  // 5. 验证注册中心统计
+  await runner.runTest('注册中心统计正常', async () => {
+    const stats = await client.call('kernel.get_registry_stats', {});
+    if (stats.total_records === undefined) {
+      throw new Error('缺少 total_records');
+    }
+    if (stats.total_records < 3) {
+      throw new Error(`注册模块数过少: ${stats.total_records}`);
+    }
+    runner.log(`  total_records: ${stats.total_records}`, 'info');
+  });
+
+  // 6. 验证事件订阅正常（require_init 中完成的订阅）
+  await runner.runTest('事件订阅验证', async () => {
+    const result = await client.call('kernel.stats', {});
+    if (!result.counters) throw new Error('缺少 counters');
+    const received = result.counters.events_received || 0;
+    if (received === 0) {
+      throw new Error('无事件收到记录（订阅可能失败）');
+    }
+    runner.log(`  events_received: ${received}`, 'info');
+  });
+
+  runner.log('');
+}
+
+window.testRequireInit = testRequireInit;

package/extensions/services/kite_console/static/js/tests/integration/scaling-control.js

@@ -0,0 +1,193 @@
+/**
+ * 扩缩容控制面集成测试
+ * 覆盖本次重构的所有修复点：
+ * 1. kernel.set_scaling RPC 权限检查（仅 Launcher 可调用）
+ * 2. 多实例 registry.register 幂等（#2~#N 不再报错）
+ * 3. 多实例连接状态一致性
+ * 4. draining 机制：路由跳过 draining 实例
+ * 5. fixed scale 守护：实例数量符合配置
+ * 6. 关闭冻结机制就绪
+ */
+
+async function testScalingControl() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【扩缩容控制面测试】', 'section');
+
+  // ── 1. kernel.set_scaling 权限检查 ──
+  runner.log('1. kernel.set_scaling 权限检查', 'subsection');
+
+  await runner.runTest('非 Launcher 调用 → 被权限拒绝', async () => {
+    try {
+      await client.call('kernel.set_scaling', { enabled: false });
+      throw new Error('应该被权限拒绝但没有');
+    } catch (e) {
+      if (e.message === '应该被权限拒绝但没有') throw e;
+      runner.log(`  预期权限错误: ${e.message}`, 'info');
+    }
+  });
+
+  // 通过 Launcher 中转调用（kite_console → launcher → kernel）
+  await runner.runTest('通过 Launcher 冻结扩缩容', async () => {
+    // 调用 launcher 暴露的 RPC 来间接冻结，或直接验证 launcher 能控制
+    // 这里通过 launcher.list_modules 确认 launcher 正常，冻结/解冻由关闭流程覆盖
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules) throw new Error('Launcher 不可用');
+    runner.log(`  Launcher 正常，共 ${result.modules.length} 个模块`, 'info');
+  });
+
+  runner.log('', 'info');
+
+  // ── 2. 多实例 registry.register 幂等 ──
+  runner.log('2. 多实例 registry.register 幂等', 'subsection');
+
+  const multiModules = ['acp_channel', 'assistant', 'phone_channel'];
+
+  for (const name of multiModules) {
+    await runner.runTest(`${name}: 注册中心状态 ready`, async () => {
+      const result = await client.call('registry.get', { path: name });
+      if (!result || !result.value) throw new Error(`${name} 未注册`);
+      if (result.value.status !== 'ready') {
+        throw new Error(`状态异常: ${result.value.status}，期望 ready`);
+      }
+    });
+  }
+
+  runner.log('', 'info');
+
+  // ── 3. 多实例连接状态一致性 ──
+  runner.log('3. 多实例连接状态一致性', 'subsection');
+
+  await runner.runTest('所有多实例模块主实例已连接', async () => {
+    const status = await client.call('kernel.connection_status', {});
+    const modules = status.modules || {};
+    for (const name of multiModules) {
+      if (!modules[name]) throw new Error(`${name} 主实例未连接`);
+    }
+    runner.log(`  ${multiModules.join(', ')} 主实例均已连接`, 'info');
+  });
+
+  // 统计各模块实际实例数
+  for (const name of multiModules) {
+    await runner.runTest(`${name}: 实例连接数量`, async () => {
+      const status = await client.call('kernel.connection_status', {});
+      const modules = status.modules || {};
+      let instanceCount = 0;
+      for (const key of Object.keys(modules)) {
+        if (key === name || key.startsWith(name + '#')) instanceCount++;
+      }
+
+      // 通过 Launcher 获取配置的 max_instances
+      let maxInst = 1;
+      try {
+        const config = await client.call('launcher.get_module_config', { module_name: name });
+        maxInst = config.max_instances || 1;
+      } catch (e) {
+        // 获取配置失败时使用默认值
+      }
+
+      runner.log(`  ${name}: 配置 max_instances=${maxInst}, 实际连接实例数=${instanceCount}`, 'info');
+      if (instanceCount === 0) throw new Error(`${name} 无任何实例连接`);
+      // 多实例模块的实例数应等于 max_instances
+      if (maxInst > 1 && instanceCount !== maxInst) {
+        runner.log(`  注意: 实例数 ${instanceCount} ≠ 配置 ${maxInst}，可能仍在启动中`, 'warn');
+      }
+    });
+  }
+
+  runner.log('', 'info');
+
+  // ── 4. draining 路由验证 ──
+  runner.log('4. draining 路由验证', 'subsection');
+
+  await runner.runTest('RPC 路由正常（未路由到不可用实例）', async () => {
+    const result = await client.call('phone_channel.get_status', {});
+    if (!result || result.status !== 'running') {
+      throw new Error(`phone_channel.get_status 返回异常: ${JSON.stringify(result)}`);
+    }
+    runner.log(`  phone_channel.get_status → ${result.status}`, 'info');
+  });
+
+  await runner.runTest('多实例 RPC 路由正常', async () => {
+    // 对 acp_channel 发 RPC（有多个实例），验证能正常返回
+    try {
+      const result = await client.call('acp_channel.get_status', {});
+      if (result && result.status) {
+        runner.log(`  acp_channel.get_status → ${result.status}`, 'info');
+      }
+    } catch (e) {
+      // acp_channel 可能没有 get_status 方法，但不应报 offline
+      if (e.message && e.message.includes('offline')) {
+        throw new Error(`acp_channel 所有实例不可达: ${e.message}`);
+      }
+      runner.log(`  acp_channel RPC 返回: ${e.message}（方法不存在，但路由正常）`, 'info');
+    }
+  });
+
+  await runner.runTest('实例压力报告正常', async () => {
+    const pressure = await client.call('kernel.instance_pressure', {});
+    const instances = pressure.instances || {};
+    const keys = Object.keys(instances);
+    runner.log(`  压力报告覆盖 ${keys.length} 个实例`, 'info');
+
+    // 列出所有多实例模块的压力数据
+    for (const name of multiModules) {
+      const moduleKeys = keys.filter(k => k === name || k.startsWith(name + '#'));
+      if (moduleKeys.length > 0) {
+        runner.log(`  ${name}: ${moduleKeys.join(', ')}`, 'info');
+      }
+    }
+  });
+
+  runner.log('', 'info');
+
+  // ── 5. fixed scale 守护机制 ──
+  runner.log('5. fixed scale 守护机制', 'subsection');
+
+  await runner.runTest('kernel stats 可用', async () => {
+    const stats = await client.call('kernel.stats', {});
+    if (!stats) throw new Error('无法获取 kernel stats');
+    runner.log(`  events_received=${stats.counters?.events_received || 0}, ` +
+               `events_routed=${stats.counters?.events_routed || 0}`, 'info');
+  });
+
+  await runner.runTest('kernel 健康检查', async () => {
+    const health = await client.call('kernel.health', {});
+    if (health.status !== 'healthy') {
+      throw new Error(`kernel 状态异常: ${health.status}`);
+    }
+    runner.log(`  status=${health.status}, modules=${health.module_count}, ` +
+               `online=${health.online_count}`, 'info');
+  });
+
+  runner.log('', 'info');
+
+  // ── 6. 关闭冻结机制验证 ──
+  runner.log('6. 关闭冻结机制就绪', 'subsection');
+
+  await runner.runTest('kernel.set_scaling RPC 已注册', async () => {
+    // 验证方法存在（非 launcher 调用会被权限拒绝，但不会报 method_not_found）
+    try {
+      await client.call('kernel.set_scaling', { enabled: true });
+    } catch (e) {
+      if (e.message && e.message.includes('not found')) {
+        throw new Error('kernel.set_scaling 方法未注册');
+      }
+      // 权限拒绝是正确的行为
+      runner.log(`  RPC 已注册（权限检查正常: ${e.message}）`, 'info');
+    }
+  });
+
+  await runner.runTest('Launcher 关闭流程可调用', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const modules = result.modules || [];
+    if (modules.length === 0) throw new Error('无法获取模块列表');
+    runner.log(`  Launcher 正常，${modules.length} 个模块可管理`, 'info');
+  });
+
+  runner.log('', 'info');
+  runner.log('✓ 扩缩容控制面测试完成', 'pass');
+}
+
+window.testScalingControl = testScalingControl;

package/extensions/services/kite_console/static/js/tests/integration/trace.js

@@ -0,0 +1,109 @@
+/**
+ * 链路追踪集成测试
+ */
+
+async function testTrace() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【链路追踪集成测试】', 'section');
+
+  let testTraceId = null;
+
+  // 测试 1：触发一次跨模块 RPC 调用，生成 trace
+  await runner.runTest('触发 RPC 生成 trace', async () => {
+    // 订阅 rpc.call.completed 事件来捕获 trace_id
+    await client.subscribe(['rpc.call.completed']);
+
+    const eventPromise = new Promise((resolve) => {
+      const handler = (data) => {
+        testTraceId = data.trace_id;
+        client.off('rpc.call.completed', handler);
+        resolve();
+      };
+      client.on('rpc.call.completed', handler);
+      setTimeout(() => resolve(), 3000); // 3秒超时
+    });
+
+    // 触发一次跨模块 RPC 调用（只有跨模块转发才会生成 trace）
+    try {
+      await client.call('watchdog.health', {});
+    } catch (e) {
+      // watchdog 可能离线，但只要事件能捕获到就行
+    }
+
+    // 等待事件
+    await eventPromise;
+
+    if (!testTraceId) throw new Error('未捕获到 trace_id');
+  });
+
+  // 测试 2：查询刚才生成的 trace
+  await runner.runTest('trace.query 查询已存在的 trace', async () => {
+    if (!testTraceId) {
+      runner.skip('trace.query (无 trace_id)');
+      return;
+    }
+
+    const result = await client.call('trace.query', { trace_id: testTraceId });
+    if (!result.found) throw new Error('trace 未找到');
+    if (!result.spans || result.spans.length === 0) throw new Error('spans 为空');
+    if (result.trace_id !== testTraceId) throw new Error('trace_id 不匹配');
+
+    // 验证 span 结构
+    const span = result.spans[0];
+    if (!span.rpc_id) throw new Error('span 缺少 rpc_id');
+    if (!span.caller) throw new Error('span 缺少 caller');
+    if (!span.target) throw new Error('span 缺少 target');
+    if (typeof span.duration !== 'number') throw new Error('span.duration 类型错误');
+    if (!span.status) throw new Error('span 缺少 status');
+  });
+
+  // 测试 3：trace.list 应该包含刚才的 trace
+  await runner.runTest('trace.list 包含新生成的 trace', async () => {
+    if (!testTraceId) {
+      runner.skip('trace.list (无 trace_id)');
+      return;
+    }
+
+    const result = await client.call('trace.list', { limit: 20 });
+    const found = result.traces.some(t => t.trace_id === testTraceId);
+    if (!found) throw new Error('trace.list 中未找到刚生成的 trace');
+  });
+
+  // 测试 4：验证 trace 深度传播（跨模块调用）
+  await runner.runTest('跨模块 RPC 调用的 trace 传播', async () => {
+    // 调用一个会触发跨模块 RPC 的方法（如 watchdog.status）
+    try {
+      await client.call('watchdog.status', {});
+
+      // 等待一下让事件传播
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      // 查询最新的 trace
+      const listResult = await client.call('trace.list', { limit: 1 });
+      if (listResult.traces.length === 0) {
+        runner.skip('跨模块 trace (无 trace 记录)');
+        return;
+      }
+
+      const latestTrace = listResult.traces[0];
+      const queryResult = await client.call('trace.query', { trace_id: latestTrace.trace_id });
+
+      // 验证有多个 span（说明跨模块调用被追踪）
+      if (queryResult.spans.length < 1) throw new Error('跨模块调用未生成多个 span');
+
+    } catch (err) {
+      // watchdog 可能不在线，跳过此测试
+      if (err.message.includes('offline') || err.message.includes('not ready')) {
+        runner.skip('跨模块 trace (watchdog 离线)');
+        return;
+      }
+      throw err;
+    }
+  });
+
+  runner.log('');
+}
+
+window.testTrace = testTrace;