@agentunion/kite 1.4.0 → 1.6.0

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

@@ -0,0 +1,75 @@
+/**
+ * Launcher 模块测试
+ */
+
+async function testLauncherModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Launcher 模块测试】', 'section');
+
+  // RPC 方法调用测试
+  runner.log('RPC 方法调用测试', 'subsection');
+
+  await runner.runTest('Launcher.list_modules', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules || !Array.isArray(result.modules)) throw new Error('缺少 modules 字段或格式错误');
+  });
+
+  await runner.runTest('Launcher.get_module_config', async () => {
+    const result = await client.call('launcher.get_module_config', { module_name: 'kernel' });
+    if (!result.name) throw new Error('缺少 name 字段');
+  });
+
+  // RPC 方法注册验证
+  runner.log('', 'info');
+  runner.log('RPC 方法注册验证', 'subsection');
+
+  const rpcMethods = [
+    { method: 'start_module', path: 'tools.rpc.launcher.start_module' },
+    { method: 'stop_module', path: 'tools.rpc.launcher.stop_module' },
+    { method: 'restart_module', path: 'tools.rpc.launcher.restart_module' },
+    { method: 'list_modules', path: 'tools.rpc.launcher.list_modules' },
+    { method: 'get_module_config', path: 'tools.rpc.module.config.get' },
+    { method: 'update_module_config', path: 'tools.rpc.module.config.update' },
+    { method: 'reset_module_config', path: 'tools.rpc.module.config.reset' }
+  ];
+
+  for (const { method, path } of rpcMethods) {
+    await runner.runTest(`launcher.${method} 注册检查`, async () => {
+      const result = await client.call('registry.lookup', {
+        field: path,
+        module: 'launcher'
+      });
+      if (!result.results || result.results.length === 0) throw new Error('未找到注册');
+    });
+  }
+
+  // 事件注册验证
+  runner.log('', 'info');
+  runner.log('事件注册验证', 'subsection');
+
+  const events = [
+    'system.ready',
+    'module.starting',
+    'module.started',
+    'module.ready',
+    'module.stopped',
+    'module.exiting',
+    'module.shutdown'
+  ];
+
+  for (const event of events) {
+    await runner.runTest(`${event} 事件注册`, async () => {
+      const result = await client.call('registry.lookup', {
+        field: `events_publish.${event}`,
+        module: 'launcher'
+      });
+      if (!result.results || result.results.length === 0) throw new Error('事件未注册');
+    });
+  }
+
+  runner.log('');
+}
+
+window.testLauncherModule = testLauncherModule;

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

@@ -0,0 +1,129 @@
+/**
+ * 模块多实例测试
+ * 验证 Kernel 多实例基础设施：配置解析、压力查询、实例跟踪
+ */
+
+async function testMultiInstanceModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【模块多实例测试】', 'section');
+
+  // 多实例测试模块（在 module.md 中配置了 max_instances=5）
+  const multiInstanceModules = ['phone_channel', 'acp_channel', 'assistant'];
+
+  // ── 1. 多实例配置基础 ──
+  runner.log('1. 多实例配置基础', 'subsection');
+
+  await runner.runTest('Kernel 健康检查', async () => {
+    const result = await client.call('kernel.health', {});
+    if (!result.status) throw new Error('Kernel 健康检查失败');
+  });
+
+  await runner.runTest('kernel.instance_pressure 接口可用', async () => {
+    const result = await client.call('kernel.instance_pressure', {});
+    if (!result || typeof result.instances === 'undefined') {
+      throw new Error('kernel.instance_pressure 返回格式异常: 缺少 instances 字段');
+    }
+  });
+
+  runner.log('', 'info');
+
+  // ── 2. 注册中心多实例字段验证 ──
+  runner.log('2. 注册中心多实例字段验证', 'subsection');
+
+  // 通过 Kernel 内部配置验证（_module_instance_config 由 module.ready 写入）
+  for (const moduleName of multiInstanceModules) {
+    await runner.runTest(`${moduleName}: 模块已注册且就绪`, async () => {
+      const result = await client.call('registry.get', { path: moduleName });
+      if (!result || !result.value) throw new Error(`模块 ${moduleName} 未注册`);
+      if (result.value.status !== 'ready') throw new Error(`模块状态非 ready: ${result.value.status}`);
+    });
+  }
+
+  // 检查连接状态中模块是否在线
+  let connStatus = {};
+  await runner.runTest('获取 Kernel 连接状态', async () => {
+    connStatus = await client.call('kernel.connection_status', {});
+    if (!connStatus.modules) throw new Error('无法获取连接状态');
+  });
+
+  for (const moduleName of multiInstanceModules) {
+    await runner.runTest(`${moduleName}: 连接已建立`, async () => {
+      const moduleConn = connStatus.modules[moduleName];
+      if (!moduleConn) throw new Error(`模块 ${moduleName} 无连接信息`);
+      const slotCount = Object.keys(moduleConn.slots || {}).length;
+      if (slotCount === 0) throw new Error('未建立任何连接');
+    });
+  }
+
+  runner.log('', 'info');
+
+  // ── 3. 压力查询接口 ──
+  runner.log('3. 压力查询接口', 'subsection');
+
+  await runner.runTest('kernel.instance_pressure 无参调用', async () => {
+    const result = await client.call('kernel.instance_pressure', {});
+    if (typeof result.instances !== 'object') throw new Error('返回格式异常');
+    runner.log(`  当前压力数据条目数: ${Object.keys(result.instances).length}`, 'info');
+  });
+
+  await runner.runTest('kernel.instance_pressure 查询不存在的模块', async () => {
+    const result = await client.call('kernel.instance_pressure', { module_id: 'nonexistent_module_xyz' });
+    if (typeof result.instances !== 'object') throw new Error('返回格式异常');
+    // 不存在的模块应返回空
+    if (Object.keys(result.instances).length > 0) {
+      throw new Error('不存在的模块不应有压力数据');
+    }
+  });
+
+  await runner.runTest('kernel.instance_pressure 查询已注册模块', async () => {
+    const result = await client.call('kernel.instance_pressure', { module_id: 'phone_channel' });
+    if (typeof result.instances !== 'object') throw new Error('返回格式异常');
+    // phone_channel 可能有也可能没有压力数据（取决于是否上报过）
+    runner.log(`  phone_channel 压力数据条目: ${Object.keys(result.instances).length}`, 'info');
+  });
+
+  runner.log('', 'info');
+
+  // ── 4. Launcher 模块列表中的多实例信息 ──
+  runner.log('4. Launcher 模块列表信息', 'subsection');
+
+  let modules = [];
+  await runner.runTest('获取模块列表', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules || !Array.isArray(result.modules)) throw new Error('无法获取模块列表');
+    modules = result.modules;
+    runner.log(`  模块总数: ${modules.length}`, 'info');
+  });
+
+  for (const moduleName of multiInstanceModules) {
+    await runner.runTest(`${moduleName}: 模块正在运行`, async () => {
+      const mod = modules.find(m => m.name === moduleName);
+      if (!mod) throw new Error(`模块 ${moduleName} 不在列表中`);
+      if (!mod.actual_state || !mod.actual_state.startsWith('running')) {
+        throw new Error(`模块未运行: ${mod.actual_state}`);
+      }
+    });
+  }
+
+  runner.log('', 'info');
+
+  // ── 5. 默认单实例验证 ──
+  runner.log('5. 默认单实例模块验证', 'subsection');
+
+  const singleInstanceModules = ['kernel', 'watchdog', 'backup'];
+  for (const moduleName of singleInstanceModules) {
+    await runner.runTest(`${moduleName}: 默认为单实例`, async () => {
+      const result = await client.call('kernel.instance_pressure', { module_id: moduleName });
+      // 单实例模块不会出现 # 分隔的实例键
+      for (const key of Object.keys(result.instances || {})) {
+        if (key.includes('#')) {
+          throw new Error(`单实例模块 ${moduleName} 不应有多实例键: ${key}`);
+        }
+      }
+    });
+  }
+}
+
+window.testMultiInstanceModule = testMultiInstanceModule;

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

@@ -0,0 +1,364 @@
+/**
+ * Phone Channel 模块完整生命周期测试
+ * 测试启动阶段、运行阶段、退出阶段的完整流程
+ */
+
+async function testPhoneChannelModule() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Phone 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 === 'phone_channel');
+    if (!module) throw new Error('phone_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 === 'phone_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 => `phone_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 = ['phone_channel.echo', 'phone_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: 'phone_channel'
+      });
+      if (!result.results || result.results.length === 0) {
+        throw new Error('RPC 方法未注册');
+      }
+    });
+  }
+
+  // ========== 第三阶段：事件注册验证 ==========
+  runner.log('', 'info');
+  runner.log('第三阶段：事件注册验证', 'subsection');
+
+  const events = ['phone_channel.test', 'phone_channel.call_started', 'phone_channel.call_ended'];
+
+  for (const event of events) {
+    await runner.runTest(`${event} 事件注册`, async () => {
+      const eventParts = event.split('.');
+      const result = await client.call('registry.lookup', {
+        field: `events_publish.${eventParts[0]}.${eventParts[1]}`,
+        module: 'phone_channel'
+      });
+      if (!result.results || result.results.length === 0) {
+        throw new Error('事件未注册');
+      }
+    });
+  }
+
+  // ========== 第四阶段：RPC 方法调用测试（单次） ==========
+  runner.log('', 'info');
+  runner.log('第四阶段：RPC 方法调用测试（单次）', 'subsection');
+
+  await runner.runTest('phone_channel.echo 单次调用', async () => {
+    const testMessage = 'Hello from test suite';
+    const result = await client.call('phone_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('phone_channel.get_status 单次调用', async () => {
+    const result = await client.call('phone_channel.get_status', {});
+    if (!result.status) throw new Error('缺少 status 字段');
+    if (result.module_id !== 'phone_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('phone_channel.echo 多次调用', async () => {
+    const iterations = 10;
+    for (let i = 0; i < iterations; i++) {
+      const result = await client.call('phone_channel.echo', {
+        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('phone_channel.echo 并发调用', async () => {
+    const concurrency = 10;
+    const promises = [];
+    for (let i = 0; i < concurrency; i++) {
+      promises.push(
+        client.call('phone_channel.echo', {
+          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');
+
+  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 === 'phone_channel') {
+          clearTimeout(timeout);
+          client.off('event', handler);
+          if (!event.data.ping_time || !event.data.pong_time) {
+            reject(new Error('pong 数据格式不正确'));
+          } else {
+            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: `test-ping-${Date.now()}`,
+        event: 'system.ping',
+        data: { ping_time: Date.now() / 1000 }
+      }).catch(reject);
+    });
+  });
+
+  // ========== 第九阶段：事件订阅和接收测试 ==========
+  runner.log('', 'info');
+  runner.log('第九阶段：事件订阅和接收测试', 'subsection');
+
+  await runner.runTest('订阅 phone_channel.test 事件', async () => {
+    await client.subscribe(['phone_channel.test']);
+  });
+
+  await runner.runTest('接收 phone_channel.test 事件', async () => {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        client.off('event', handler);
+        reject(new Error('18秒内未收到事件'));
+      }, 18000);
+
+      const handler = (event) => {
+        if (event.event === 'phone_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('phone_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('phone_channel.echo', {
+        wrong_param: 'test'
+      });
+      // phone_channel.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',
+      'module.shutdown.ack',
+      'module.shutdown.ready',
+      'module.stopped',
+      'module.exiting'
+    ]);
+  });
+
+  await runner.runTest('发送 shutdown 信号并验证事件时序', async () => {
+    const receivedEvents = [];
+    const expectedSequence = ['module.shutdown.ack', 'module.shutdown.ready', 'module.stopped'];
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        client.off('event', handler);
+        reject(new Error(`15秒内未完成 shutdown 流程，已收到事件: ${receivedEvents.join(', ')}`));
+      }, 15000);
+
+      const handler = (event) => {
+        if (event.data && event.data.module_id === 'phone_channel') {
+          if (expectedSequence.includes(event.event)) {
+            receivedEvents.push(event.event);
+            runner.log(`  收到事件: ${event.event}`, 'info');
+
+            // 检查是否收到所有预期事件
+            if (receivedEvents.length === expectedSequence.length) {
+              clearTimeout(timeout);
+              client.off('event', handler);
+
+              // 验证事件顺序
+              for (let i = 0; i < expectedSequence.length; i++) {
+                if (receivedEvents[i] !== expectedSequence[i]) {
+                  reject(new Error(`事件顺序错误: 期望 ${expectedSequence[i]}，实际 ${receivedEvents[i]}`));
+                  return;
+                }
+              }
+
+              runner.log(`  ✓ 事件时序正确: ${receivedEvents.join(' → ')}`, 'info');
+              resolve();
+            }
+          }
+        }
+      };
+
+      client.on('event', handler);
+
+      // 发送 shutdown 信号
+      client.call('event.publish', {
+        event_id: `test-shutdown-${Date.now()}`,
+        event: 'module.shutdown',
+        data: { module_id: 'phone_channel', reason: 'test' }
+      }).catch(reject);
+    });
+  });
+
+  await runner.runTest('验证模块已停止', async () => {
+    // 等待 2 秒确保模块完全停止
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    const result = await client.call('launcher.list_modules', {});
+    const module = result.modules.find(m => m.name === 'phone_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');
+  });
+
+  await runner.runTest('重新启动模块', async () => {
+    await client.call('launcher.start_module', { module_name: 'phone_channel' });
+
+    // 等待 3 秒让模块启动
+    await new Promise(resolve => setTimeout(resolve, 3000));
+
+    const result = await client.call('launcher.list_modules', {});
+    const module = result.modules.find(m => m.name === 'phone_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.testPhoneChannelModule = testPhoneChannelModule;