@leadfund/lead-mcp 0.0.0-stage → 202610.2.0

package/test/http.test.mjs

@@ -0,0 +1,284 @@
+/**
+ * HTTP(S) 传输端到端测试
+ *
+ * <p>覆盖两种云端协议：</p>
+ * <ul>
+ *     <li>{@code sse}  —— GET /sse 建流 + POST /messages 回传</li>
+ *     <li>{@code http} —— Streamable HTTP 的 POST /mcp</li>
+ * </ul>
+ *
+ * <p>同时验证鉴权：没有 Bearer 令牌一律 401。</p>
+ *
+ * <p>运行：node test/http.test.mjs</p>
+ */
+
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import assert from "node:assert/strict";
+
+const CLI = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
+  "..",
+  "src",
+  "cli.js",
+);
+const AUTH_TOKEN = "test-token-123";
+
+let passed = 0;
+
+/**
+ * 断言
+ *
+ * @param {string} name 用例名
+ * @param {Function} fn 断言函数
+ */
+async function test(name, fn) {
+  try {
+    await fn();
+    passed += 1;
+    console.log(`✓ ${name}`);
+  } catch (error) {
+    console.error(`✗ ${name}\n  ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+/**
+ * 起一个 mock 的 dmmp-system
+ */
+async function startMockBackend() {
+  const server = createServer((req, res) => {
+    let body = "";
+    req.on("data", (c) => {
+      body += c;
+    });
+    req.on("end", () => {
+      res.setHeader("Content-Type", "application/json");
+      res.end(
+        JSON.stringify({
+          code: 0,
+          message: "接口调用成功",
+          data: {
+            found: true,
+            memberId: "M10086",
+            memberIdList: ["M10086"],
+            name: "张*",
+            mobileFormat: "138****0000",
+            idTypeFormat: "身份证",
+            idNoFormat: "310101********1234",
+            idValidityFormat: "长期有效",
+          },
+        }),
+      );
+    });
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  return { server, port: server.address().port };
+}
+
+/**
+ * 起一个 lead-mcp 的 HTTP 模式实例
+ */
+async function startHttpMode(transport, extraArgs = []) {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lead-mcp-http-"));
+  const child = spawn(
+    process.execPath,
+    [
+      CLI,
+      "--transport",
+      transport,
+      "--auth-token",
+      AUTH_TOKEN,
+      "--http-port",
+      "0",
+      ...extraArgs,
+    ],
+    { stdio: ["pipe", "pipe", "pipe"] },
+  );
+
+  let stderr = "";
+  child.stderr.on("data", (c) => {
+    stderr += c.toString();
+  });
+
+  // 从启动日志里拿实际端口（--http-port 0 表示随机端口）
+  const port = await new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new Error(`启动超时\n${stderr}`)),
+      15000,
+    );
+    child.stderr.on("data", () => {
+      const match = stderr.match(/端点=http:\/\/[^:]+:(\d+)/);
+      if (match) {
+        clearTimeout(timer);
+        resolve(Number(match[1]));
+      }
+    });
+  });
+
+  return { child, port, getStderr: () => stderr };
+}
+
+/**
+ * SSE：建立流，拿到 sessionId，再通过 POST /messages 发 initialize
+ */
+async function sseHandshake(port, withAuth = true) {
+  const headers = withAuth ? { Authorization: `Bearer ${AUTH_TOKEN}` } : {};
+  const controller = new AbortController();
+  const res = await fetch(`http://127.0.0.1:${port}/sse`, {
+    headers,
+    signal: controller.signal,
+  });
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let sessionId = null;
+  let firstMessage = null;
+
+  // 读第一帧：event: endpoint 里带 sessionId
+  while (!sessionId) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const match = buffer.match(/sessionId=([0-9a-f-]+)/);
+    if (match) {
+      sessionId = match[1];
+    }
+  }
+
+  const post = async (message) => {
+    await fetch(`http://127.0.0.1:${port}/messages?sessionId=${sessionId}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(message),
+    });
+  };
+
+  await post({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "http-test", version: "0.0.1" },
+    },
+  });
+
+  // 从流里读 initialize 的响应
+  const deadline = Date.now() + 10000;
+  while (!firstMessage && Date.now() < deadline) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const match = buffer.match(/data: (\{.*?\})\r?\n/);
+    if (match) {
+      firstMessage = JSON.parse(match[1]);
+    }
+  }
+
+  controller.abort();
+  return { sessionId, firstMessage };
+}
+
+async function main() {
+  const mock = await startMockBackend();
+  const baseUrl = `http://127.0.0.1:${mock.port}`;
+
+  // 配置文件里指定后端地址
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "lead-mcp-cfg-"));
+  const configFile = path.join(tmpDir, "config.json");
+  fs.writeFileSync(
+    configFile,
+    JSON.stringify({ environments: { test: [baseUrl] } }),
+  );
+
+  // ---- SSE ----
+  const sse = await startHttpMode("sse", [
+    "--base-url",
+    baseUrl,
+    "--env",
+    "test",
+  ]);
+
+  await test("SSE：未带令牌返回 401", async () => {
+    const res = await fetch(`http://127.0.0.1:${sse.port}/sse`);
+    assert.equal(res.status, 401);
+  });
+
+  await test("SSE：健康检查不鉴权", async () => {
+    const res = await fetch(`http://127.0.0.1:${sse.port}/health`);
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.equal(body.ok, true);
+    assert.equal(body.transport, "sse");
+  });
+
+  await test("SSE：握手并能查到客户信息", async () => {
+    const { sessionId, firstMessage } = await sseHandshake(sse.port);
+    assert.ok(sessionId, "应拿到 sessionId");
+    assert.ok(firstMessage, "应收到 initialize 响应");
+    assert.equal(firstMessage.result.serverInfo.name, "lead-mcp");
+  });
+
+  sse.child.kill();
+
+  // ---- Streamable HTTP ----
+  const stream = await startHttpMode("http", ["--base-url", baseUrl]);
+
+  await test("HTTP：未带令牌返回 401", async () => {
+    const res = await fetch(`http://127.0.0.1:${stream.port}/mcp`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize" }),
+    });
+    assert.equal(res.status, 401);
+  });
+
+  await test("HTTP：initialize 返回服务器信息", async () => {
+    const res = await fetch(`http://127.0.0.1:${stream.port}/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${AUTH_TOKEN}`,
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "http-test", version: "0.0.1" },
+        },
+      }),
+    });
+    assert.equal(res.status, 200);
+    const text = await res.text();
+    // Streamable HTTP 可能以 SSE 帧返回，data 后面是完整的嵌套 JSON
+    const match = text.match(/data: (\{[\s\S]*\})/) ?? text.match(/(\{[\s\S]*\})/);
+    assert.ok(match, `应返回 MCP 响应，实际: ${text.slice(0, 200)}`);
+    const body = JSON.parse(match[1]);
+    assert.equal(body.result.serverInfo.name, "lead-mcp");
+  });
+
+  stream.child.kill();
+  mock.server.close();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  if (process.exitCode) {
+    console.error("\n有用例失败 ❌");
+  } else {
+    console.log(`\n全部通过（${passed} 个用例）✅`);
+  }
+}
+
+main().catch((error) => {
+  console.error("HTTP 测试失败:", error);
+  process.exit(1);
+});

package/test/smoke.mjs

@@ -0,0 +1,348 @@
+/**
+ * 端到端冒烟测试
+ *
+ * <p>起一个 mock 的 dmmp-system，再以子进程方式拉起真实的 MCP Server，
+ * 走完整的 MCP 协议握手（initialize → tools/list → tools/call），
+ * 校验工具清单、命中、未命中、参数非法、下游异常五种场景的返回语义。</p>
+ *
+ * <p>运行：node test/smoke.mjs</p>
+ */
+
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import assert from "node:assert/strict";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI = path.join(__dirname, "..", "src", "cli.js");
+
+/**
+ * mock 的 dmmp-system
+ */
+function startMockBackend() {
+  const state = { lastHeaders: null };
+  const server = createServer((req, res) => {
+    state.lastHeaders = req.headers;
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      const params = body ? JSON.parse(body) : {};
+      res.setHeader("Content-Type", "application/json");
+
+      if (params.mobile === "13800000000") {
+        res.end(
+          JSON.stringify({
+            code: 0,
+            message: "接口调用成功",
+            data: {
+              found: true,
+              memberId: "M10086",
+              name: "张*",
+              mobile: "13800000000",
+              mobileFormat: "138****0000",
+              idType: "01",
+              idTypeFormat: "身份证",
+              idNo: "310101199001011234",
+              idNoFormat: "310101********1234",
+              idValidity: "9999-12-31",
+              idValidityFormat: "长期有效",
+            },
+          }),
+        );
+        return;
+      }
+      if (params.memberId === "M20001") {
+        // 带上 memberId 复查：唯一命中
+        res.end(
+          JSON.stringify({
+            code: 0,
+            message: "接口调用成功",
+            data: {
+              found: true,
+              memberId: "M20001",
+              memberIdList: ["M20001"],
+              name: "李*",
+              mobileFormat: "136****0000",
+              idTypeFormat: "身份证",
+              idNoFormat: "310101********5678",
+              idValidityFormat: "长期有效",
+            },
+          }),
+        );
+        return;
+      }
+      if (params.mobile === "13600000000") {
+        // 一个手机号对应多个会员：后端只返回候选会员号，不返回档案
+        res.end(
+          JSON.stringify({
+            code: 0,
+            message: "接口调用成功",
+            data: { found: true, memberIdList: ["M20001", "M20002"] },
+          }),
+        );
+        return;
+      }
+      if (params.mobile === "13900000000") {
+        res.statusCode = 500;
+        res.end(JSON.stringify({ code: 500, message: "下游服务异常" }));
+        return;
+      }
+      // 未命中
+      res.end(JSON.stringify({ code: 0, message: "接口调用成功", data: { found: false } }));
+    });
+  });
+  return new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      resolve({ server, port: server.address().port, state });
+    });
+  });
+}
+
+/**
+ * 以 stdio 方式拉起 MCP Server，并提供 JSON-RPC 调用能力
+ */
+function startMcpServer(baseUrl, extraArgs = []) {
+  const child = spawn(
+    process.execPath,
+    [CLI, "--base-url", baseUrl, "--operator", "E10086", ...extraArgs],
+    { stdio: ["pipe", "pipe", "pipe"] },
+  );
+
+  const pending = new Map();
+  let buffer = "";
+  let stderr = "";
+
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString();
+    let index;
+    while ((index = buffer.indexOf("\n")) >= 0) {
+      const line = buffer.slice(0, index).trim();
+      buffer = buffer.slice(index + 1);
+      if (!line) {
+        continue;
+      }
+      const message = JSON.parse(line);
+      const resolver = pending.get(message.id);
+      if (resolver) {
+        pending.delete(message.id);
+        resolver(message);
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+
+  let nextId = 1;
+  function send(method, params) {
+    const id = nextId;
+    nextId += 1;
+    const message = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`请求超时: ${method}\n${stderr}`));
+      }, 10000);
+      pending.set(id, (response) => {
+        clearTimeout(timer);
+        resolve(response);
+      });
+      child.stdin.write(`${JSON.stringify(message)}\n`);
+    });
+  }
+
+  function notify(method, params) {
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  }
+
+  return { child, send, notify, getStderr: () => stderr };
+}
+
+/**
+ * 取一个已被占用的端口（先监听再关闭），用来模拟不可用的节点
+ *
+ * @returns {Promise<number>} 端口
+ */
+async function getClosedPort() {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+
+/**
+ * 故障转移：第一个节点不可用时自动切到第二个
+ */
+async function testFailover() {
+  const closedPort = await getClosedPort();
+  const { server: mock, port } = await startMockBackend();
+  const mcp = startMcpServer(`http://127.0.0.1:${closedPort},http://127.0.0.1:${port}`);
+
+  try {
+    const init = await mcp.send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "smoke-test", version: "0.0.1" },
+    });
+    assert.equal(init.result.serverInfo.name, "lead-mcp");
+    mcp.notify("notifications/initialized");
+
+    const hit = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13800000000" },
+    });
+    assert.ok(!hit.result.isError, "首节点不可用时应自动切到第二个节点");
+    assert.ok(hit.result.content[0].text.includes("M10086"), "应命中第二个节点的数据");
+    console.log("✓ 节点故障转移（首个节点不可用 → 自动切换）");
+  } finally {
+    mcp.child.kill();
+    mock.close();
+  }
+}
+
+async function main() {
+  const { server: mock, port, state } = await startMockBackend();
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const mcp = startMcpServer(baseUrl);
+
+  try {
+    // 1. initialize
+    const init = await mcp.send("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "smoke-test", version: "0.0.1" },
+    });
+    assert.equal(init.result.serverInfo.name, "lead-mcp", "serverInfo.name");
+    console.log("✓ initialize", JSON.stringify(init.result.serverInfo));
+    mcp.notify("notifications/initialized");
+
+    // 2. tools/list
+    const list = await mcp.send("tools/list", {});
+    const tools = list.result.tools;
+    assert.equal(tools.length, 1, "应当只有一个工具");
+    const tool = tools[0];
+    assert.equal(tool.name, "dmmp_query_account");
+    assert.ok(tool.description.includes("未查询到"), "描述里要写清未查询到的处理方式");
+    const props = tool.inputSchema.properties;
+    assert.ok(props.mobile && props.idNo && props.ownerNet, "参数应包含 mobile/idNo/ownerNet");
+    assert.equal(tool.inputSchema.required, undefined, "mobile/idNo 非必填，由服务端校验二者其一");
+    console.log("✓ tools/list", tool.name, JSON.stringify(tool.inputSchema.required ?? []));
+
+    // 3. 命中
+    const hit = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13800000000" },
+    });
+    const hitText = hit.result.content[0].text;
+    assert.ok(!hit.result.isError, "命中不应是错误");
+    assert.ok(hitText.includes("M10086"), "应返回会员id");
+    assert.ok(hitText.includes("138****0000"), "应返回脱敏手机号");
+    assert.ok(hitText.includes("310101********1234"), "应返回脱敏证件号");
+    assert.ok(hitText.includes("长期有效"), "应返回证件有效期");
+    console.log("✓ tools/call 命中\n", hitText.split("\n").map((l) => `    ${l}`).join("\n"));
+
+    // 4. 未命中：正常返回，不是错误
+    const miss = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13700000000" },
+    });
+    assert.ok(!miss.result.isError, "未命中不应标记为错误");
+    assert.equal(miss.result.content[0].text, "未查询到该客户信息。");
+    console.log("✓ tools/call 未命中（非错误）", miss.result.content[0].text);
+
+    // 5. 参数非法：缺少手机号、身份证号与会员号
+    const invalid = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { ownerNet: "0001" },
+    });
+    assert.equal(invalid.result.isError, true, "参数非法应为错误");
+    assert.ok(invalid.result.content[0].text.includes("至少"));
+    console.log("✓ tools/call 参数非法（isError）", invalid.result.content[0].text);
+
+    // 6. 下游异常：isError
+    const broken = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13900000000" },
+    });
+    assert.equal(broken.result.isError, true, "下游异常应为错误");
+    console.log("✓ tools/call 下游异常（isError）", broken.result.content[0].text);
+
+    // 7. 命中多个会员：不是错误，要列出候选会员号让用户确认
+    const multi = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13600000000" },
+    });
+    assert.ok(!multi.result.isError, "多会员命中不应标记为错误");
+    const multiText = multi.result.content[0].text;
+    assert.ok(multiText.includes("M20001"), "应列出候选会员号");
+    assert.ok(multiText.includes("M20002"), "应列出候选会员号");
+    assert.ok(multiText.includes("memberId"), "应提示用 memberId 重新查询");
+    console.log("✓ tools/call 多会员命中（非错误）\n" + multiText.split("\n").map((l) => `    ${l}`).join("\n"));
+
+    // 8. 指定网点却查不到：提示该客户不在该网点下
+    const missWithNet = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { mobile: "13700000000", ownerNet: "0001" },
+    });
+    assert.ok(!missWithNet.result.isError, "未命中不应标记为错误");
+    assert.ok(
+      missWithNet.result.content[0].text.includes("0001"),
+      "指定网点未命中时应说明是网点范围问题",
+    );
+    console.log("✓ tools/call 指定网点未命中", missWithNet.result.content[0].text);
+
+    // 9. 带上 memberId 复查：应命中唯一账户
+    const byMemberId = await mcp.send("tools/call", {
+      name: "dmmp_query_account",
+      arguments: { memberId: "M20001", mobile: "13600000000" },
+    });
+    assert.ok(!byMemberId.result.isError, "按 memberId 复查不应是错误");
+    assert.ok(byMemberId.result.content[0].text.includes("会员id：M20001"), "按 memberId 应命中唯一账户");
+    console.log("✓ tools/call 带 memberId 复查", byMemberId.result.content[0].text.split("\n")[0]);
+
+    // 10. 调用方身份必须随请求透传给后端（限流与审计依赖它）
+    const headers = state.lastHeaders ?? {};
+    assert.equal(headers["x-operator"], "E10086", "应透传操作人标识");
+    assert.ok(headers["x-operator-os"], "应透传操作人操作系统账号");
+    console.log(
+      "✓ 操作人身份透传",
+      `X-Operator=${headers["x-operator"]} X-Operator-Os=${headers["x-operator-os"]}`,
+    );
+
+    // 11. 环境标识必须随请求透传，服务端审计要能区分打在哪个环境
+    assert.equal(headers["x-lead-env"], "custom", "应透传环境标识");
+    console.log("✓ 环境标识透传", `X-Lead-Env=${headers["x-lead-env"]}`);
+
+    // 12. 日志必须走 stderr：stdout 全程只承载 JSON-RPC（上面的解析已经证明）
+    assert.ok(
+      mcp.getStderr().includes("[lead-mcp]"),
+      "日志应输出到 stderr",
+    );
+    assert.ok(
+      mcp.getStderr().includes("已启动"),
+      "启动日志应输出到 stderr",
+    );
+    console.log("✓ 日志输出位置 stderr（stdout 仅承载 JSON-RPC）");
+  } finally {
+    mcp.child.kill();
+    mock.close();
+  }
+
+  console.log("\n全部通过 ✅");
+}
+
+main()
+  .then(() => testFailover())
+  .then(() => {
+    console.log("故障转移用例通过 ✅");
+  })
+  .catch((error) => {
+    console.error("冒烟测试失败:", error);
+    process.exit(1);
+  });