@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/kite_console/static/js/tests/ARCHITECTURE.md

@@ -0,0 +1,67 @@
+# Evol 前端测试架构重构总结
+
+## 改动概览
+
+将原有的单一注册中心测试重构为模块化的测试中心，支持：
+- 模块测试（单独测试各个模块）
+- 集成测试（测试跨模块流程和机制）
+- 完整测试（运行所有测试并生成报告）
+
+## 文件变更
+
+### 新增文件
+```
+extensions/services/evol/static/js/tests/
+├── test-runner.js                    # 测试运行器核心
+├── index.js                          # 测试入口和调度
+├── README.md                         # 测试架构说明
+├── modules/                          # 模块测试目录
+│   ├── kernel.js
+│   ├── launcher.js
+│   ├── watchdog.js
+│   ├── web.js
+│   └── backup.js
+└── integration/                      # 集成测试目录
+    ├── registry-core.js              # 注册中心核心功能
+    ├── pingpong.js                   # Ping-Pong 机制
+    ├── auth.js                       # 认证机制
+    └── full-workflow.js              # 完整流程
+```
+
+### 修改文件
+- `index.html`：重构测试 UI，添加测试分类 Tab
+- `style.css`：添加测试 Tab 样式
+- `evol-app.js`：重构测试方法，添加报告下载功能
+
+### 保留文件
+- `registry-tests.js`：保留旧测试文件（未删除，但不再使用）
+
+## 测试分类
+
+### 模块测试
+- Kernel：list_modules, get_module_info, ping
+- Launcher：get_processes, ping
+- Watchdog：get_status, ping
+- Web：get_config, ping
+- Backup：get_status, ping
+
+### 集成测试
+- 注册中心核心功能：模块列表、RPC 方法列表、事件列表
+- Ping-Pong 机制：所有模块的 Ping 响应
+- 认证机制：Token 验证
+- 完整流程：启动状态、WebSocket 连接、事件订阅
+
+## 测试报告
+
+完整测试会生成两个日志文件：
+1. `kite-test-full-{timestamp}.log`：完整日志
+2. `kite-test-errors-{timestamp}.log`：错误日志
+
+## 扩展性
+
+新增测试只需：
+1. 创建测试文件
+2. 在 `index.js` 中注册
+3. 在 `index.html` 中引入脚本和添加选项
+
+测试代码完全模块化，易于维护和扩展。

package/extensions/services/kite_console/static/js/tests/README.md

@@ -0,0 +1,140 @@
+# Kite 测试中心
+
+## 目录结构
+
+```
+tests/
+├── test-runner.js          # 测试运行器核心
+├── index.js                # 测试入口和调度
+├── modules/                # 模块测试
+│   ├── kernel.js           # Kernel 模块测试
+│   ├── launcher.js         # Launcher 模块测试
+│   ├── watchdog.js         # Watchdog 模块测试
+│   ├── web.js              # Web 模块测试
+│   └── backup.js           # Backup 模块测试
+└── integration/            # 集成测试
+    ├── registry-core.js    # 注册中心核心功能
+    ├── pingpong.js         # Ping-Pong 机制
+    ├── auth.js             # 认证机制
+    └── full-workflow.js    # 完整流程
+```
+
+## 测试分类
+
+### 1. 模块测试
+测试各个模块的功能，包括：
+- **RPC 方法调用**：测试模块提供的所有 RPC 接口
+- **事件订阅**：测试模块的事件发布/订阅机制
+- **API 接口**：测试模块的 HTTP API（如适用）
+- **Hook 机制**：测试模块的钩子函数（如适用）
+
+### 2. 集成测试
+测试跨模块的流程和机制：
+- **注册中心核心功能**：模块列表、RPC 方法列表、事件列表
+- **Ping-Pong 机制**：所有模块的 Ping 响应
+- **认证机制**：Token 存在性和格式验证
+- **完整流程**：模块启动、WebSocket 连接、事件订阅
+
+### 3. 完整测试
+运行所有测试项，生成完整的测试报告。
+
+## 使用方法
+
+### 前端 UI
+1. 打开 Evol 控制台
+2. 进入"模块管理"页面
+3. 在"测试中心"板块选择测试类型：
+   - **模块测试**：选择模块后点击"运行测试"
+   - **集成测试**：选择测试项后点击"运行测试"
+   - **完整测试**：点击"运行完整测试"，完成后可下载报告
+
+### 编程接口
+```javascript
+// 初始化测试运行器
+window.testRunner.init(kernelClient);
+
+// 运行模块测试
+await window.runModuleTest('kernel');
+
+// 运行集成测试
+await window.runIntegrationTest('pingpong');
+
+// 运行完整测试
+const report = await window.runFullTest();
+```
+
+## 测试报告
+
+测试输出实时显示在前端页面，测试完成后自动上传到后端保存。
+
+### 后端日志路径
+
+日志保存在 `C:/Users/agentcp/.kite/workspace/Kite/evol/log/` 目录：
+- **模块测试**：`module_test_{module_name}.log`（如 `module_test_kernel.log`）
+- **集成测试**：`integration_test_{test_name}.log`（如 `integration_test_pingpong.log`）
+- **完整测试**：`full_test.log`
+
+完整路径示例：
+```
+C:/Users/agentcp/.kite/workspace/Kite/evol/log/module_test_kernel.log
+C:/Users/agentcp/.kite/workspace/Kite/evol/log/integration_test_pingpong.log
+C:/Users/agentcp/.kite/workspace/Kite/evol/log/full_test.log
+```
+
+每次测试会覆盖同名日志文件。
+
+### 前端下载报告
+
+完整测试会生成两个可下载的日志文件：
+1. **完整日志**：`kite-test-full-{timestamp}.log` - 包含所有测试项的详细执行过程
+2. **错误日志**：`kite-test-errors-{timestamp}.log` - 只包含失败的测试项
+
+报告格式：
+```
+Kite 测试报告 - 2026-03-11T12:00:00
+============================================================
+
+总计: 20 | 通过: 18 | 失败: 2 | 跳过: 0
+通过率: 90.0%
+
+============================================================
+
+[2026-03-11 12:00:01.123] ✓ Kernel.list_modules
+[2026-03-11 12:00:01.456] ✗ Kernel.get_module_info: 缺少 name 字段
+...
+```
+
+## 添加新测试
+
+### 添加模块测试
+1. 在 `modules/` 目录创建 `{module_name}.js`
+2. 实现测试函数：
+```javascript
+async function test{ModuleName}Module() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【{ModuleName} 模块测试】', 'section');
+
+  await runner.runTest('测试名称', async () => {
+    // 测试逻辑
+    const result = await client.call('module', 'method', {});
+    if (!result) throw new Error('测试失败');
+  });
+
+  runner.log('');
+}
+
+window.test{ModuleName}Module = test{ModuleName}Module;
+```
+
+3. 在 `index.js` 的 `MODULE_TESTS` 中注册
+4. 在 `index.html` 中引入脚本
+5. 在 `index.html` 的 `module-select` 中添加选项
+
+### 添加集成测试
+1. 在 `integration/` 目录创建 `{test_name}.js`
+2. 实现测试函数（同上）
+3. 在 `index.js` 的 `INTEGRATION_TESTS` 中注册
+4. 在 `index.html` 中引入脚本
+5. 在 `index.html` 的 `integration-select` 中添加选项

package/extensions/services/kite_console/static/js/tests/index.js

@@ -0,0 +1,161 @@
+/**
+ * Kite 测试中心 - 主入口
+ */
+
+// 测试类型定义
+const TEST_TYPES = {
+  MODULE: 'module',
+  INTEGRATION: 'integration',
+  FULL: 'full'
+};
+
+// 模块测试映射
+const MODULE_TESTS = {
+  kernel: 'testKernelModule',
+  launcher: 'testLauncherModule',
+  watchdog: 'testWatchdogModule',
+  web: 'testWebModule',
+  backup: 'testBackupModule',
+  acp_channel: 'testAcpChannelModule',
+  phone_channel: 'testPhoneChannelModule',
+  auth: 'testAuthModule',
+  gateway: 'testGatewayModule',
+  redis: 'testRedisModule',
+  multi_instance: 'testMultiInstanceModule'
+};
+
+// 集成测试映射
+const INTEGRATION_TESTS = {
+  'registry-core': 'testRegistryCore',
+  'pingpong': 'testPingPong',
+  'auth': 'testAuth',
+  'full-workflow': 'testFullWorkflow',
+  'channel-interaction': 'testChannelInteraction',
+  'nested-rpc': 'testNestedRpc',
+  'trace': 'testTrace',
+  'elastic-connection': 'testElasticConnection',
+  'remote-deploy': 'testRemoteDeploy',
+  'require-init': 'testRequireInit',
+  'redis': 'testRedisIntegration',
+  'multi-instance': 'testMultiInstance',
+  'scaling-control': 'testScalingControl'
+};
+
+/**
+ * 运行模块测试
+ */
+async function runModuleTest(moduleName) {
+  const runner = window.testRunner;
+  const testFn = window[MODULE_TESTS[moduleName]];
+
+  if (!testFn) {
+    runner.log(`模块测试 ${moduleName} 不存在`, 'fail');
+    return;
+  }
+
+  runner.reset();
+  runner.log(`开始测试模块: ${moduleName}`, 'section');
+  runner.log('', 'info');
+
+  await testFn();
+
+  const report = runner.generateReport();
+  displayTestSummary(report.summary);
+
+  // 自动上传日志
+  runner.log('', 'info');
+  await runner.uploadLog(`module_test_${moduleName}`);
+}
+
+/**
+ * 运行集成测试
+ */
+async function runIntegrationTest(testName) {
+  const runner = window.testRunner;
+  const testFn = window[INTEGRATION_TESTS[testName]];
+
+  if (!testFn) {
+    runner.log(`集成测试 ${testName} 不存在`, 'fail');
+    return;
+  }
+
+  runner.reset();
+  runner.log(`开始集成测试: ${testName}`, 'section');
+  runner.log('', 'info');
+
+  await testFn();
+
+  const report = runner.generateReport();
+  displayTestSummary(report.summary);
+
+  // 自动上传日志
+  runner.log('', 'info');
+  await runner.uploadLog(`integration_test_${testName}`);
+}
+
+/**
+ * 运行完整测试
+ */
+async function runFullTest() {
+  const runner = window.testRunner;
+  runner.reset();
+
+  runner.log('========================================', 'section');
+  runner.log('Kite 完整测试套件', 'section');
+  runner.log('========================================', 'section');
+  runner.log('', 'info');
+
+  // 1. 集成测试
+  runner.log('【第一部分：集成测试】', 'section');
+  runner.log('', 'info');
+
+  for (const testName of Object.keys(INTEGRATION_TESTS)) {
+    await window[INTEGRATION_TESTS[testName]]();
+  }
+
+  // 2. 模块测试
+  // DEBUG: 诊断 Part1→Part2 过渡时的连接状态
+  const client = runner.kernelClient;
+  const wsState = client.ws ? ['CONNECTING','OPEN','CLOSING','CLOSED'][client.ws.readyState] : 'null';
+  runner.log(`DEBUG: Part1→Part2 连接状态: authenticated=${client.authenticated}, ws=${wsState}, lastCloseCode=${client.lastCloseCode}`, 'info');
+  console.log(`[TestRunner] DEBUG: Part1→Part2 transition — authenticated=${client.authenticated}, ws.readyState=${wsState}, lastCloseCode=${client.lastCloseCode}`);
+
+  runner.log('【第二部分：模块测试】', 'section');
+  runner.log('', 'info');
+
+  for (const moduleName of Object.keys(MODULE_TESTS)) {
+    await window[MODULE_TESTS[moduleName]]();
+  }
+
+  // 生成报告
+  const report = runner.generateReport();
+
+  runner.log('', 'info');
+  runner.log('========================================', 'section');
+  runner.log('测试完成', 'section');
+  runner.log('========================================', 'section');
+
+  displayTestSummary(report.summary);
+
+  // 自动上传日志
+  runner.log('', 'info');
+  await runner.uploadLog('full_test');
+
+  return report;
+}
+
+/**
+ * 显示测试摘要
+ */
+function displayTestSummary(summary) {
+  const runner = window.testRunner;
+
+  runner.log('', 'info');
+  runner.log(`总计: ${summary.total} | 通过: ${summary.passed} | 失败: ${summary.failed} | 跳过: ${summary.skipped}`, 'info');
+  runner.log(`通过率: ${summary.passRate}%`, summary.failed === 0 ? 'pass' : 'fail');
+}
+
+// 导出到全局
+window.runModuleTest = runModuleTest;
+window.runIntegrationTest = runIntegrationTest;
+window.runFullTest = runFullTest;

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

@@ -0,0 +1,120 @@
+/**
+ * 认证机制测试
+ */
+
+async function testAuth() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【认证机制测试】', 'section');
+
+  await runner.runTest('Token 存在性检查', async () => {
+    const token = localStorage.getItem('kiteToken');
+    if (!token) throw new Error('Token 不存在');
+  });
+
+  await runner.runTest('Token 格式验证', async () => {
+    const token = localStorage.getItem('kiteToken');
+    if (token.length < 32) throw new Error('Token 格式无效');
+  });
+
+  // 配对码生成 → get_pending_codes 返回非空
+  runner.log('', 'info');
+  runner.log('配对码全流程测试', 'subsection');
+
+  let generatedCodeCount = 0;
+
+  await runner.runTest('配对码生成 → get_pending_codes 非空', async () => {
+    await client.call('auth.request_pairing_code', { role: 'admin' });
+    const result = await client.call('auth.get_pending_codes', {});
+    if (!result.codes || result.codes.length === 0) throw new Error('生成后 pending codes 应非空');
+    generatedCodeCount = result.count;
+  });
+
+  // 配对码验证 → auth.verify 成功
+  let verifiedCode = null;
+
+  await runner.runTest('配对码验证成功', async () => {
+    const pending = await client.call('auth.get_pending_codes', {});
+    if (pending.codes.length === 0) throw new Error('没有可用配对码');
+    verifiedCode = pending.codes[0].code;
+    const result = await client.call('auth.verify', {
+      method: 'pairing_code',
+      code: verifiedCode,
+      client_info: { device_id: 'test-integration', device_name: 'Integration Test' }
+    });
+    if (!result.success) throw new Error(`验证失败: ${result.error}`);
+    if (!result.token) throw new Error('验证成功但缺少 token');
+  });
+
+  // 验证后配对码被消费
+  await runner.runTest('验证后配对码被消费', async () => {
+    const result = await client.call('auth.get_pending_codes', {});
+    const remaining = result.codes.map(c => c.code);
+    if (remaining.includes(verifiedCode)) throw new Error('已验证的配对码不应出现在 pending 列表');
+  });
+
+  // Token 列表增加
+  runner.log('', 'info');
+  runner.log('Token 管理测试', 'subsection');
+
+  let tokenCountBefore = 0;
+
+  await runner.runTest('Token 列表增长', async () => {
+    const result = await client.call('auth.list_tokens', {});
+    tokenCountBefore = result.count;
+    if (tokenCountBefore < 1) throw new Error('验证成功后应至少有 1 个 token');
+  });
+
+  // Token 撤销
+  await runner.runTest('Token 撤销', async () => {
+    // 先生成一个新配对码并验证，得到一个可撤销的 token
+    await client.call('auth.request_pairing_code', { role: 'admin' });
+    const pending = await client.call('auth.get_pending_codes', {});
+    const code = pending.codes[0].code;
+    const verifyResult = await client.call('auth.verify', {
+      method: 'pairing_code',
+      code: code,
+      client_info: { device_id: 'test-revoke', device_name: 'Revoke Test' }
+    });
+    if (!verifyResult.success) throw new Error('验证失败');
+    const newToken = verifyResult.token;
+
+    // 撤销
+    const revokeResult = await client.call('auth.revoke_token', { token: newToken });
+    if (!revokeResult.success) throw new Error('撤销失败');
+
+    // 确认列表中不再包含
+    const listResult = await client.call('auth.list_tokens', {});
+    const prefixes = listResult.tokens.map(t => t.token_prefix);
+    const revokedPrefix = newToken.substring(0, 10) + '...';
+    if (prefixes.includes(revokedPrefix)) throw new Error('撤销后 token 不应出现在列表中');
+  });
+
+  // 速率限制
+  runner.log('', 'info');
+  runner.log('速率限制测试', 'subsection');
+
+  await runner.runTest('配对码速率限制（超过 3 个返回错误）', async () => {
+    // 先清理：验证掉所有 pending codes
+    let pending = await client.call('auth.get_pending_codes', {});
+    for (const c of pending.codes) {
+      await client.call('auth.verify', { method: 'pairing_code', code: c.code });
+    }
+
+    // 连续生成 3 个
+    for (let i = 0; i < 3; i++) {
+      const r = await client.call('auth.request_pairing_code', { role: 'admin' });
+      if (r.success === false) throw new Error(`第 ${i + 1} 个配对码生成不应失败`);
+    }
+
+    // 第 4 个应该失败
+    const r = await client.call('auth.request_pairing_code', { role: 'admin' });
+    if (r.success !== false) throw new Error('超过上限应返回 success=false');
+    if (!r.error || !r.error.includes('Too many')) throw new Error(`错误信息不正确: ${r.error}`);
+  });
+
+  runner.log('');
+}
+
+window.testAuth = testAuth;

package/extensions/services/kite_console/static/js/tests/integration/channel-interaction.js

@@ -0,0 +1,188 @@
+/**
+ * Channel 互动测试 - 测试 acp_channel 和 phone_channel 之间的 RPC 和事件交互
+ */
+
+async function testChannelInteraction() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Channel 互动测试】', 'section');
+
+  // 1. 检查两个模块是否都在运行
+  await runner.runTest('检查 acp_channel 和 phone_channel 运行状态', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const acpChannel = result.modules.find(m => m.name === 'acp_channel');
+    const phoneChannel = result.modules.find(m => m.name === 'phone_channel');
+
+    if (!acpChannel) throw new Error('acp_channel 模块不存在');
+    if (!phoneChannel) throw new Error('phone_channel 模块不存在');
+
+    if (!acpChannel.actual_state || !acpChannel.actual_state.startsWith('running')) {
+      throw new Error(`acp_channel 未运行 (状态: ${acpChannel.actual_state})`);
+    }
+    if (!phoneChannel.actual_state || !phoneChannel.actual_state.startsWith('running')) {
+      throw new Error(`phone_channel 未运行 (状态: ${phoneChannel.actual_state})`);
+    }
+
+    runner.log(`  acp_channel: ${acpChannel.actual_state}`, 'info');
+    runner.log(`  phone_channel: ${phoneChannel.actual_state}`, 'info');
+  });
+
+  // 2. 检查模块注册信息（使用 registry.lookup + registry.get）
+  await runner.runTest('检查模块注册信息', async () => {
+    // 通过 registry.lookup 查找 acp_channel 和 phone_channel 的 RPC 方法
+    const acpMethods = await client.call('registry.lookup', {
+      field: 'tools.rpc.module.*', module: 'acp_channel'
+    });
+    const phoneMethods = await client.call('registry.lookup', {
+      field: 'tools.rpc.module.*', module: 'phone_channel'
+    });
+
+    if (acpMethods.results.length === 0) throw new Error('acp_channel 未注册或无 RPC 方法');
+    if (phoneMethods.results.length === 0) throw new Error('phone_channel 未注册或无 RPC 方法');
+
+    // 检查关键 RPC 方法是否存在
+    const acpMethodNames = acpMethods.results.map(r => r.field.split('.').pop());
+    const phoneMethodNames = phoneMethods.results.map(r => r.field.split('.').pop());
+
+    if (!acpMethodNames.includes('echo')) throw new Error('acp_channel.echo 方法未注册');
+    if (!acpMethodNames.includes('get_status')) throw new Error('acp_channel.get_status 方法未注册');
+    if (!phoneMethodNames.includes('echo')) throw new Error('phone_channel.echo 方法未注册');
+    if (!phoneMethodNames.includes('get_status')) throw new Error('phone_channel.get_status 方法未注册');
+
+    runner.log(`  acp_channel RPC 方法: ${acpMethodNames.map(m => 'acp_channel.' + m).join(', ')}`, 'info');
+    runner.log(`  phone_channel RPC 方法: ${phoneMethodNames.map(m => 'phone_channel.' + m).join(', ')}`, 'info');
+  });
+
+  // 3. 测试 acp_channel.echo RPC 调用
+  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 || !result.echo) throw new Error('返回结果缺少 echo 字段');
+    if (result.echo !== testMessage) throw new Error(`返回值不匹配: ${result.echo}`);
+    if (!result.timestamp) throw new Error('返回结果缺少 timestamp 字段');
+
+    runner.log(`  返回: ${JSON.stringify(result)}`, 'info');
+  });
+
+  // 4. 测试 acp_channel.get_status RPC 调用
+  await runner.runTest('调用 acp_channel.get_status', async () => {
+    const result = await client.call('acp_channel.get_status', {});
+
+    if (!result || !result.status) throw new Error('返回结果缺少 status 字段');
+    if (!result.module_id) throw new Error('返回结果缺少 module_id 字段');
+    if (result.module_id !== 'acp_channel') throw new Error(`module_id 不匹配: ${result.module_id}`);
+    if (typeof result.uptime !== 'number') throw new Error('返回结果缺少 uptime 字段');
+
+    runner.log(`  返回: ${JSON.stringify(result)}`, 'info');
+  });
+
+  // 5. 测试 phone_channel.echo RPC 调用
+  await runner.runTest('调用 phone_channel.echo', async () => {
+    const testMessage = 'Hello from test suite to phone';
+    const result = await client.call('phone_channel.echo', { message: testMessage });
+
+    if (!result || !result.echo) throw new Error('返回结果缺少 echo 字段');
+    if (result.echo !== testMessage) throw new Error(`返回值不匹配: ${result.echo}`);
+    if (!result.timestamp) throw new Error('返回结果缺少 timestamp 字段');
+
+    runner.log(`  返回: ${JSON.stringify(result)}`, 'info');
+  });
+
+  // 6. 测试 phone_channel.get_status RPC 调用
+  await runner.runTest('调用 phone_channel.get_status', async () => {
+    const result = await client.call('phone_channel.get_status', {});
+
+    if (!result || !result.status) throw new Error('返回结果缺少 status 字段');
+    if (!result.module_id) throw new Error('返回结果缺少 module_id 字段');
+    if (result.module_id !== 'phone_channel') throw new Error(`module_id 不匹配: ${result.module_id}`);
+    if (typeof result.uptime !== 'number') throw new Error('返回结果缺少 uptime 字段');
+
+    runner.log(`  返回: ${JSON.stringify(result)}`, 'info');
+  });
+
+  // 7. 测试事件订阅和发布
+  await runner.runTest('测试事件订阅和发布', async () => {
+    // 订阅两个模块的测试事件
+    await client.subscribe(['acp_channel.test', 'phone_channel.test']);
+
+    let acpEventReceived = false;
+    let phoneEventReceived = false;
+
+    // 设置事件监听器
+    const acpHandler = (data) => {
+      runner.log(`  收到 acp_channel.test 事件: ${data.message}`, 'info');
+      acpEventReceived = true;
+    };
+    const phoneHandler = (data) => {
+      runner.log(`  收到 phone_channel.test 事件: ${data.message}`, 'info');
+      phoneEventReceived = true;
+    };
+
+    client.on('acp_channel.test', acpHandler);
+    client.on('phone_channel.test', phoneHandler);
+
+    // 等待事件（最多等待 20 秒）
+    runner.log('  等待事件发布（最多 20 秒）...', 'info');
+    const startTime = Date.now();
+    while ((!acpEventReceived || !phoneEventReceived) && (Date.now() - startTime < 20000)) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    // 清理监听器
+    client.off('acp_channel.test', acpHandler);
+    client.off('phone_channel.test', phoneHandler);
+
+    if (!acpEventReceived) throw new Error('未收到 acp_channel.test 事件');
+    if (!phoneEventReceived) throw new Error('未收到 phone_channel.test 事件');
+  });
+
+  // 8. 测试跨模块 RPC 调用（通过日志验证）
+  await runner.runTest('验证跨模块 RPC 调用（日志检查）', async () => {
+    runner.log('  提示: 查看模块日志验证跨模块 RPC 调用', 'info');
+    runner.log('  - acp_channel 应该调用 phone_channel.get_status', 'info');
+    runner.log('  - phone_channel 应该调用 acp_channel.echo', 'info');
+    runner.log('  - 日志路径: {KITE_INSTANCE_DIR}/acp_channel/log/latest.log', 'info');
+    runner.log('  - 日志路径: {KITE_INSTANCE_DIR}/phone_channel/log/latest.log', 'info');
+    // 这个测试总是通过，因为我们无法直接验证日志内容
+  });
+
+  // 9. 压力测试：连续调用 RPC
+  await runner.runTest('压力测试：连续调用 RPC (10次)', async () => {
+    const iterations = 10;
+    let successCount = 0;
+
+    for (let i = 0; i < iterations; i++) {
+      try {
+        const result = await client.call('acp_channel.echo', {
+          message: `Stress test ${i + 1}`
+        });
+        if (result && result.echo) successCount++;
+      } catch (err) {
+        runner.log(`  第 ${i + 1} 次调用失败: ${err.message}`, 'warn');
+      }
+    }
+
+    if (successCount < iterations) {
+      throw new Error(`成功率: ${successCount}/${iterations} (${(successCount/iterations*100).toFixed(1)}%)`);
+    }
+
+    runner.log(`  成功率: ${successCount}/${iterations} (100%)`, 'info');
+  });
+
+  // 10. 错误处理测试：调用不存在的方法
+  await runner.runTest('错误处理：调用不存在的方法', async () => {
+    try {
+      await client.call('acp_channel.nonexistent', {});
+      throw new Error('应该抛出错误但没有');
+    } catch (err) {
+      if (err.message.includes('应该抛出错误')) throw err;
+      runner.log(`  正确捕获错误: ${err.message}`, 'info');
+    }
+  });
+
+  runner.log('');
+}
+
+window.testChannelInteraction = testChannelInteraction;