@agentunion/kite 1.5.0 → 1.6.0

package/extensions/services/kite_console/static/js/tests/integration/nested-rpc.js

@@ -0,0 +1,266 @@
+/**
+ * 嵌套 RPC 调用测试
+ * 测试模块间的相互调用和嵌套调用场景
+ */
+
+async function testNestedRpc() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【嵌套 RPC 调用测试】', 'section');
+
+  // ========== 第一部分：验证模块运行状态 ==========
+  runner.log('', 'info');
+  runner.log('第一部分：验证模块运行状态', 'subsection');
+
+  let acpRunning = false;
+  let phoneRunning = false;
+
+  await runner.runTest('检查 acp_channel 和 phone_channel 状态', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    const acp = result.modules.find(m => m.name === 'acp_channel');
+    const phone = result.modules.find(m => m.name === 'phone_channel');
+
+    if (!acp) throw new Error('acp_channel 不存在');
+    if (!phone) throw new Error('phone_channel 不存在');
+
+    acpRunning = acp.actual_state && acp.actual_state.startsWith('running');
+    phoneRunning = phone.actual_state && phone.actual_state.startsWith('running');
+
+    if (!acpRunning) throw new Error(`acp_channel 未运行: ${acp.actual_state}`);
+    if (!phoneRunning) throw new Error(`phone_channel 未运行: ${phone.actual_state}`);
+
+    runner.log(`  acp_channel: ${acp.actual_state}`, 'info');
+    runner.log(`  phone_channel: ${phone.actual_state}`, 'info');
+  });
+
+  if (!acpRunning || !phoneRunning) {
+    runner.log('', 'info');
+    runner.log('⚠ 需要两个模块都在运行，跳过后续测试', 'skip');
+    return;
+  }
+
+  // ========== 第二部分：单向 RPC 调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第二部分：单向 RPC 调用测试', 'subsection');
+
+  await runner.runTest('Evol → acp_channel.echo', async () => {
+    const result = await client.call('acp_channel.echo', { message: 'test from evol' });
+    if (!result.echo || result.echo !== 'test from evol') {
+      throw new Error('调用失败');
+    }
+    runner.log(`  返回: ${result.echo}`, 'info');
+  });
+
+  await runner.runTest('Evol → phone_channel.echo', async () => {
+    const result = await client.call('phone_channel.echo', { message: 'test from evol' });
+    if (!result.echo || result.echo !== 'test from evol') {
+      throw new Error('调用失败');
+    }
+    runner.log(`  返回: ${result.echo}`, 'info');
+  });
+
+  // ========== 第三部分：连续双向调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第三部分：连续双向调用测试', 'subsection');
+
+  await runner.runTest('Evol → acp_channel → Evol → phone_channel', async () => {
+    // 第一步：调用 acp_channel
+    const result1 = await client.call('acp_channel.get_status', {});
+    if (!result1.module_id || result1.module_id !== 'acp_channel') {
+      throw new Error('第一步调用失败');
+    }
+    runner.log(`  步骤1: acp_channel.get_status 成功`, 'info');
+
+    // 第二步：调用 phone_channel
+    const result2 = await client.call('phone_channel.get_status', {});
+    if (!result2.module_id || result2.module_id !== 'phone_channel') {
+      throw new Error('第二步调用失败');
+    }
+    runner.log(`  步骤2: phone_channel.get_status 成功`, 'info');
+
+    // 第三步：再次调用 acp_channel
+    const result3 = await client.call('acp_channel.echo', { message: 'round 2' });
+    if (!result3.echo || result3.echo !== 'round 2') {
+      throw new Error('第三步调用失败');
+    }
+    runner.log(`  步骤3: acp_channel.echo 成功`, 'info');
+  });
+
+  // ========== 第四部分：并发双向调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第四部分：并发双向调用测试', 'subsection');
+
+  await runner.runTest('并发调用两个模块（各5次）', async () => {
+    const promises = [];
+
+    // 5 个对 acp_channel 的调用
+    for (let i = 0; i < 5; i++) {
+      promises.push(
+        client.call('acp_channel.echo', { message: `acp ${i + 1}` })
+      );
+    }
+
+    // 5 个对 phone_channel 的调用
+    for (let i = 0; i < 5; i++) {
+      promises.push(
+        client.call('phone_channel.echo', { message: `phone ${i + 1}` })
+      );
+    }
+
+    const results = await Promise.all(promises);
+
+    // 验证前 5 个结果
+    for (let i = 0; i < 5; i++) {
+      if (!results[i].echo || results[i].echo !== `acp ${i + 1}`) {
+        throw new Error(`acp_channel 调用 ${i + 1} 失败`);
+      }
+    }
+
+    // 验证后 5 个结果
+    for (let i = 0; i < 5; i++) {
+      if (!results[i + 5].echo || results[i + 5].echo !== `phone ${i + 1}`) {
+        throw new Error(`phone_channel 调用 ${i + 1} 失败`);
+      }
+    }
+
+    runner.log(`  成功完成 10 个并发调用`, 'info');
+  });
+
+  // ========== 第五部分：快速交替调用测试 ==========
+  runner.log('', 'info');
+  runner.log('第五部分：快速交替调用测试（20次）', 'subsection');
+
+  await runner.runTest('快速交替调用两个模块', async () => {
+    const iterations = 20;
+    for (let i = 0; i < iterations; i++) {
+      const method = i % 2 === 0 ? 'acp_channel.echo' : 'phone_channel.echo';
+      const message = `alternate ${i + 1}`;
+
+      const result = await client.call(method, { message: message });
+
+      if (!result.echo || result.echo !== message) {
+        throw new Error(`第 ${i + 1} 次调用失败`);
+      }
+    }
+    runner.log(`  成功完成 ${iterations} 次交替调用`, 'info');
+  });
+
+  // ========== 第六部分：调用链超时测试 ==========
+  runner.log('', 'info');
+  runner.log('第六部分：调用链超时测试', 'subsection');
+
+  await runner.runTest('验证 RPC 调用不会死锁', async () => {
+    // 创建一个超时保护的调用
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error('调用超时（可能死锁）')), 10000);
+    });
+
+    const callPromise = (async () => {
+      // 连续调用多次，确保不会死锁
+      for (let i = 0; i < 5; i++) {
+        await client.call('acp_channel.get_status', {});
+
+        await client.call('phone_channel.get_status', {});
+      }
+    })();
+
+    await Promise.race([callPromise, timeoutPromise]);
+    runner.log(`  调用链正常，无死锁`, 'info');
+  });
+
+  // ========== 第七部分：错误恢复测试 ==========
+  runner.log('', 'info');
+  runner.log('第七部分：错误恢复测试', 'subsection');
+
+  await runner.runTest('调用失败后继续调用', async () => {
+    // 第一步：故意调用不存在的方法
+    try {
+      await client.call('acp_channel.nonexistent', {});
+      throw new Error('应该抛出错误');
+    } catch (err) {
+      if (err.message.includes('应该抛出错误')) throw err;
+      runner.log(`  步骤1: 正确捕获错误`, 'info');
+    }
+
+    // 第二步：验证后续调用仍然正常
+    const result = await client.call('acp_channel.echo', { message: 'recovery test' });
+
+    if (!result.echo || result.echo !== 'recovery test') {
+      throw new Error('恢复调用失败');
+    }
+    runner.log(`  步骤2: 恢复调用成功`, 'info');
+  });
+
+  // ========== 第八部分：真正的嵌套 RPC 调用 ==========
+  runner.log('', 'info');
+  runner.log('第八部分：嵌套 RPC 调用（A→B→A）', 'subsection');
+
+  await runner.runTest('acp_channel.nested_call → 内部调用 phone_channel.echo', async () => {
+    const result = await client.call('acp_channel.nested_call', { message: 'hello nested' });
+
+    if (result.module_id !== 'acp_channel') {
+      throw new Error(`返回模块不正确: ${result.module_id}`);
+    }
+    if (result.nested_call_to !== 'phone_channel.echo') {
+      throw new Error(`嵌套目标不正确: ${result.nested_call_to}`);
+    }
+    if (!result.nested_result || result.nested_result.echo !== 'nested from acp: hello nested') {
+      throw new Error(`嵌套结果不正确: ${JSON.stringify(result.nested_result)}`);
+    }
+    runner.log(`  acp → phone_channel.echo 嵌套调用成功`, 'info');
+    runner.log(`  嵌套返回: ${result.nested_result.echo}`, 'info');
+  });
+
+  await runner.runTest('phone_channel.nested_call → 内部调用 acp_channel.echo', async () => {
+    const result = await client.call('phone_channel.nested_call', { message: 'hello nested' });
+
+    if (result.module_id !== 'phone_channel') {
+      throw new Error(`返回模块不正确: ${result.module_id}`);
+    }
+    if (result.nested_call_to !== 'acp_channel.echo') {
+      throw new Error(`嵌套目标不正确: ${result.nested_call_to}`);
+    }
+    if (!result.nested_result || result.nested_result.echo !== 'nested from phone: hello nested') {
+      throw new Error(`嵌套结果不正确: ${JSON.stringify(result.nested_result)}`);
+    }
+    runner.log(`  phone → acp_channel.echo 嵌套调用成功`, 'info');
+    runner.log(`  嵌套返回: ${result.nested_result.echo}`, 'info');
+  });
+
+  // ========== 第九部分：并发嵌套调用 ==========
+  runner.log('', 'info');
+  runner.log('第九部分：并发嵌套调用', 'subsection');
+
+  await runner.runTest('并发执行两个方向的嵌套调用', async () => {
+    const [acpResult, phoneResult] = await Promise.all([
+      client.call('acp_channel.nested_call', { message: 'concurrent 1' }),
+      client.call('phone_channel.nested_call', { message: 'concurrent 2' })
+    ]);
+
+    if (!acpResult.nested_result || acpResult.nested_result.echo !== 'nested from acp: concurrent 1') {
+      throw new Error(`acp 嵌套结果不正确`);
+    }
+    if (!phoneResult.nested_result || phoneResult.nested_result.echo !== 'nested from phone: concurrent 2') {
+      throw new Error(`phone 嵌套结果不正确`);
+    }
+    runner.log(`  双向并发嵌套调用成功`, 'info');
+  });
+
+  await runner.runTest('连续 5 次嵌套调用', async () => {
+    for (let i = 0; i < 5; i++) {
+      const method = i % 2 === 0 ? 'acp_channel.nested_call' : 'phone_channel.nested_call';
+
+      const result = await client.call(method, { message: `loop ${i + 1}` });
+
+      if (!result.nested_result) {
+        throw new Error(`第 ${i + 1} 次嵌套调用失败`);
+      }
+    }
+    runner.log(`  连续 5 次嵌套调用全部成功`, 'info');
+  });
+
+  runner.log('');
+}
+
+window.testNestedRpc = testNestedRpc;

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

@@ -0,0 +1,25 @@
+/**
+ * 健康检查测试
+ */
+
+async function testPingPong() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【健康检查测试】', 'section');
+
+  await runner.runTest('Kernel 健康检查', 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('模块列表获取', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules || result.modules.length === 0) throw new Error('模块列表为空');
+  });
+
+  runner.log('');
+}
+
+window.testPingPong = testPingPong;

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

@@ -0,0 +1,227 @@
+/**
+ * Redis 集成测试 — 跨模块场景、数据完整性、并发安全
+ */
+
+async function testRedisIntegration() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【Redis 集成测试】', 'section');
+
+  // ── 生命周期 ──
+  runner.log('生命周期验证', 'subsection');
+
+  await runner.runTest('Redis 模块已就绪', async () => {
+    const result = await client.call('redis.status', {});
+    if (result.module_id !== 'redis') throw new Error(`模块名错误: ${result.module_id}`);
+    if (result.status !== 'running') throw new Error(`状态错误: ${result.status}`);
+  });
+
+  await runner.runTest('system.redis_ready 事件已发布', async () => {
+    const result = await client.call('registry.lookup', {
+      field: 'events_publish.system.redis_ready',
+      module: 'redis'
+    });
+    if (!result.results || result.results.length === 0) throw new Error('Redis 未注册事件');
+  });
+
+  await runner.runTest('redis.info 返回连接信息', async () => {
+    const info = await client.call('redis.info', {});
+    if (!info.host || !info.port) throw new Error('连接信息缺失');
+    runner.log(`  Redis 类型: ${info.type}, 地址: ${info.host}:${info.port}`, 'info');
+  });
+
+  await runner.runTest('注册中心可查询 Redis 连接信息', async () => {
+    const result = await client.call('registry.lookup', {
+      field: 'services.redis',
+      module: 'redis'
+    });
+    if (!result.results || result.results.length === 0) throw new Error('注册中心无 Redis 连接信息');
+    const info = result.results[0].value;
+    if (!info.host || !info.port || !info.protocol) throw new Error('连接信息不完整');
+    runner.log(`  注册中心: ${info.host}:${info.port} (${info.protocol}, ${info.type})`, 'info');
+  });
+
+  // ── 字符串完整流程 ──
+  runner.log('', 'info');
+  runner.log('字符串完整流程 (SET → GET → EXPIRE → DEL)', 'subsection');
+
+  await runner.runTest('字符串 CRUD 完整流程', async () => {
+    const key = 'integ:str:' + Date.now();
+    // SET
+    await client.call('redis.set', { key, value: 'test_value' });
+    // GET
+    const get1 = await client.call('redis.get', { key });
+    if (get1.value !== 'test_value') throw new Error('GET 失败');
+    // 覆盖写
+    await client.call('redis.set', { key, value: 'new_value' });
+    const get2 = await client.call('redis.get', { key });
+    if (get2.value !== 'new_value') throw new Error('覆盖写失败');
+    // EXPIRE
+    await client.call('redis.expire', { key, seconds: 3600 });
+    // DEL
+    await client.call('redis.del', { key });
+    const get3 = await client.call('redis.get', { key });
+    if (get3.value !== null && get3.value !== undefined) throw new Error('DEL 后仍能 GET');
+  });
+
+  // ── 哈希完整流程 ──
+  runner.log('', 'info');
+  runner.log('哈希完整流程 (HSET → HGET → HGETALL → HDEL)', 'subsection');
+
+  await runner.runTest('哈希 CRUD 完整流程', async () => {
+    const key = 'integ:hash:' + Date.now();
+    // HSET 多字段
+    await client.call('redis.hset', { key, field: 'name', value: 'Kite' });
+    await client.call('redis.hset', { key, field: 'version', value: '1.0' });
+    await client.call('redis.hset', { key, field: 'type', value: 'service' });
+    // HGET
+    const name = await client.call('redis.hget', { key, field: 'name' });
+    if (name.value !== 'Kite') throw new Error('HGET name 失败');
+    // HGETALL
+    const all = await client.call('redis.hgetall', { key });
+    if (!all.data) throw new Error('HGETALL 缺少 data');
+    if (Object.keys(all.data).length !== 3) throw new Error(`期望3个字段, 得到 ${Object.keys(all.data).length}`);
+    if (all.data.version !== '1.0') throw new Error('HGETALL version 不匹配');
+    // HDEL
+    await client.call('redis.hdel', { key, field: 'type' });
+    const afterDel = await client.call('redis.hgetall', { key });
+    if (afterDel.data.type) throw new Error('HDEL 后 type 仍存在');
+    if (Object.keys(afterDel.data).length !== 2) throw new Error('HDEL 后字段数错误');
+    // 清理
+    await client.call('redis.del', { key });
+  });
+
+  // ── 集合完整流程 ──
+  runner.log('', 'info');
+  runner.log('集合完整流程 (SADD → SMEMBERS → SREM)', 'subsection');
+
+  await runner.runTest('集合 CRUD 完整流程', async () => {
+    const key = 'integ:set:' + Date.now();
+    // SADD
+    const add1 = await client.call('redis.sadd', { key, members: ['redis', 'mysql', 'mongo'] });
+    if (add1.added !== 3) throw new Error(`期望添加3, 得到 ${add1.added}`);
+    // SADD 重复
+    const add2 = await client.call('redis.sadd', { key, members: ['redis', 'pg'] });
+    if (add2.added !== 1) throw new Error(`重复添加应只加1, 得到 ${add2.added}`);
+    // SMEMBERS
+    const members = await client.call('redis.smembers', { key });
+    if (members.members.length !== 4) throw new Error(`期望4个成员, 得到 ${members.members.length}`);
+    // SREM
+    const rem = await client.call('redis.srem', { key, members: ['mongo', 'mysql'] });
+    if (rem.removed !== 2) throw new Error(`期望移除2, 得到 ${rem.removed}`);
+    const after = await client.call('redis.smembers', { key });
+    if (after.members.length !== 2) throw new Error(`移除后期望2个, 得到 ${after.members.length}`);
+    // 清理
+    await client.call('redis.del', { key });
+  });
+
+  // ── PUBLISH 测试 ──
+  runner.log('', 'info');
+  runner.log('发布测试 (PUBLISH)', 'subsection');
+
+  await runner.runTest('PUBLISH 命令可执行', async () => {
+    const result = await client.call('redis.publish', { channel: 'integ:ch', message: 'hello_kite' });
+    if (result.receivers === undefined) throw new Error('缺少 receivers 字段');
+  });
+
+  // ── 跨模块场景 ──
+  runner.log('', 'info');
+  runner.log('跨模块共享状态场景', 'subsection');
+
+  await runner.runTest('模拟多模块共享计数器', async () => {
+    const key = 'shared:counter';
+    // 模块A 写入
+    await client.call('redis.set', { key, value: '100' });
+    // 模块B 读取
+    const read = await client.call('redis.get', { key });
+    if (read.value !== '100') throw new Error('共享读取失败');
+    // 模块C 覆盖
+    await client.call('redis.set', { key, value: '200' });
+    // 模块A 再次读取
+    const read2 = await client.call('redis.get', { key });
+    if (read2.value !== '200') throw new Error('共享覆盖后读取失败');
+    await client.call('redis.del', { key });
+  });
+
+  await runner.runTest('模拟多模块共享哈希状态', async () => {
+    const key = 'shared:module_status';
+    await client.call('redis.hset', { key, field: 'phone_channel', value: 'online' });
+    await client.call('redis.hset', { key, field: 'model_service', value: 'online' });
+    await client.call('redis.hset', { key, field: 'gateway', value: 'degraded' });
+    const all = await client.call('redis.hgetall', { key });
+    if (Object.keys(all.data).length !== 3) throw new Error('模块状态数量错误');
+    if (all.data.gateway !== 'degraded') throw new Error('gateway 状态错误');
+    await client.call('redis.del', { key });
+  });
+
+  // ── 并发安全 ──
+  runner.log('', 'info');
+  runner.log('并发安全测试', 'subsection');
+
+  await runner.runTest('并发写入10个不同 key', async () => {
+    const promises = [];
+    for (let i = 0; i < 10; i++) {
+      promises.push(client.call('redis.set', { key: `concurrent:${i}`, value: `val_${i}` }));
+    }
+    await Promise.all(promises);
+    // 验证全部写入成功
+    for (let i = 0; i < 10; i++) {
+      const r = await client.call('redis.get', { key: `concurrent:${i}` });
+      if (r.value !== `val_${i}`) throw new Error(`key concurrent:${i} 值错误`);
+    }
+    // 清理
+    for (let i = 0; i < 10; i++) {
+      await client.call('redis.del', { key: `concurrent:${i}` });
+    }
+  });
+
+  await runner.runTest('并发操作不同数据类型', async () => {
+    const promises = [
+      client.call('redis.set', { key: 'mix:str', value: 'hello' }),
+      client.call('redis.hset', { key: 'mix:hash', field: 'f', value: 'v' }),
+      client.call('redis.sadd', { key: 'mix:set', members: ['a', 'b'] }),
+    ];
+    await Promise.all(promises);
+    const [str, hash, set] = await Promise.all([
+      client.call('redis.get', { key: 'mix:str' }),
+      client.call('redis.hget', { key: 'mix:hash', field: 'f' }),
+      client.call('redis.smembers', { key: 'mix:set' }),
+    ]);
+    if (str.value !== 'hello') throw new Error('字符串并发写入失败');
+    if (hash.value !== 'v') throw new Error('哈希并发写入失败');
+    if (set.members.length !== 2) throw new Error('集合并发写入失败');
+    // 清理
+    await Promise.all([
+      client.call('redis.del', { key: 'mix:str' }),
+      client.call('redis.del', { key: 'mix:hash' }),
+      client.call('redis.del', { key: 'mix:set' }),
+    ]);
+  });
+
+  // ── 错误处理 ──
+  runner.log('', 'info');
+  runner.log('错误处理测试', 'subsection');
+
+  await runner.runTest('redis.get 缺少 key 参数应报错', async () => {
+    try {
+      await client.call('redis.get', {});
+      throw new Error('应该抛出异常');
+    } catch (e) {
+      if (e.message === '应该抛出异常') throw e;
+    }
+  });
+
+  await runner.runTest('redis.hset 缺少参数应报错', async () => {
+    try {
+      await client.call('redis.hset', { key: 'test' });
+      throw new Error('应该抛出异常');
+    } catch (e) {
+      if (e.message === '应该抛出异常') throw e;
+    }
+  });
+
+  runner.log('');
+}
+
+window.testRedisIntegration = testRedisIntegration;

package/extensions/services/kite_console/static/js/tests/integration/registry-core.js

@@ -0,0 +1,52 @@
+/**
+ * 注册中心核心功能测试
+ */
+
+async function testRegistryCore() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【注册中心核心功能测试】', 'section');
+
+  // 1. 测试 registry.lookup 基本功能
+  await runner.runTest('registry.lookup 基本调用', async () => {
+    const result = await client.call('registry.lookup', {});
+    if (!result.results || !Array.isArray(result.results)) throw new Error('返回结果格式错误');
+    if (typeof result.last_update_time !== 'number') throw new Error('缺少 last_update_time');
+  });
+
+  // 2. 测试 registry.get 精确查询
+  await runner.runTest('registry.get 精确查询', async () => {
+    const result = await client.call('registry.get', { path: 'launcher.module_id' });
+    if (result.value !== 'launcher') throw new Error('查询结果不正确');
+  });
+
+  // 3. 测试 glob 模式匹配
+  await runner.runTest('registry.lookup glob 模式', async () => {
+    const result = await client.call('registry.lookup', { field: 'tools.rpc.module.*' });
+    if (!result.results || result.results.length === 0) throw new Error('glob 匹配失败');
+  });
+
+  // 4. 测试统计数据
+  await runner.runTest('获取 Kernel 统计数据', async () => {
+    const result = await client.call('kernel.stats', {});
+    if (!result.counters) throw new Error('缺少 counters 字段');
+    if (!result.rpc) throw new Error('缺少 rpc 字段');
+  });
+
+  // 5. 测试注册中心统计
+  await runner.runTest('获取注册中心统计', async () => {
+    const result = await client.call('kernel.get_registry_stats', {});
+    if (result.total_records === undefined) throw new Error('缺少 total_records 字段');
+  });
+
+  // 6. 测试模块列表
+  await runner.runTest('获取模块列表', async () => {
+    const result = await client.call('launcher.list_modules', {});
+    if (!result.modules || result.modules.length === 0) throw new Error('模块列表为空');
+  });
+
+  runner.log('');
+}
+
+window.testRegistryCore = testRegistryCore;

package/extensions/services/kite_console/static/js/tests/integration/remote-deploy.js

@@ -0,0 +1,85 @@
+/**
+ * 远程部署与双模式启动集成测试
+ */
+
+async function testRemoteDeploy() {
+  const runner = window.testRunner;
+  const client = runner.kernelClient;
+
+  runner.log('【远程部署与双模式启动测试】', 'section');
+
+  // 测试 1：Gateway 模块是否在线
+  await runner.runTest('Gateway 模块状态检查', async () => {
+    try {
+      const result = await client.call('registry.lookup', { module: 'gateway' });
+      if (!result.results || result.results.length === 0) {
+        runner.skip('Gateway 模块未启动');
+        return;
+      }
+    } catch (err) {
+      runner.skip('Gateway 模块未启动');
+    }
+  });
+
+  // 测试 2：Auth 模块远程认证接口
+  await runner.runTest('auth.verify 接口可用性', async () => {
+    try {
+      // 尝试验证一个无效 token（预期失败，但接口应该存在）
+      await client.call('auth.verify', { token: 'invalid-token-for-test' });
+    } catch (err) {
+      // 预期会失败，但不应该是 METHOD_NOT_FOUND
+      if (err.message && err.message.includes('Method not found')) {
+        throw new Error('auth.verify 方法不存在');
+      }
+      // 其他错误（如 Invalid token）是正常的
+    }
+  });
+
+  // 测试 3：Launcher 申请 client token 接口
+  await runner.runTest('launcher.request_client_token 接口', async () => {
+    try {
+      const result = await client.call('launcher.request_client_token', {
+        module_id: 'test_module',
+        kite_token: 'test-kite-token'
+      });
+      // 预期会失败（无效的 kite_token），但接口应该存在
+    } catch (err) {
+      if (err.message && err.message.includes('Method not found')) {
+        throw new Error('launcher.request_client_token 方法不存在');
+      }
+      // 其他错误是正常的
+    }
+  });
+
+  // 测试 4：检查远程模块注册信息
+  await runner.runTest('远程模块注册信息检查', async () => {
+    const result = await client.call('registry.lookup', {});
+
+    // 检查是否有模块声明了 gateway_url
+    let hasRemoteModule = false;
+    for (const item of result.results) {
+      if (item.field === 'metadata.gateway_url') {
+        hasRemoteModule = true;
+        break;
+      }
+    }
+
+    if (!hasRemoteModule) {
+      runner.skip('当前无远程模块');
+    }
+  });
+
+  // 测试 5：多连接 offer/release 事件
+  await runner.runTest('system.connection.offer 事件订阅', async () => {
+    try {
+      await client.subscribe(['system.connection.offer', 'system.connection.release']);
+      // 订阅成功
+    } catch (err) {
+      throw new Error(`事件订阅失败: ${err.message}`);
+    }
+  });
+
+  runner.log('');
+}
+
+window.testRemoteDeploy = testRemoteDeploy;