MCPサーバーをJSON-RPCでテストする｜stdio最小ハーネス

{
  "jsonrpc": "2.0",
  "id": "discover-1",
  "method": "server/discover",
  "params": {
    "_meta": {
      "io.modelcontextprotocol/protocolVersion": "2026-07-28",
      "io.modelcontextprotocol/clientInfo": {
        "name": "raw-stdio-probe",
        "version": "1.0.0"
      },
      "io.modelcontextprotocol/clientCapabilities": {}
    }
  }
}

import { spawn } from "node:child_process";
import { createInterface } from "node:readline";

const [command, ...args] = process.argv.slice(2);
if (!command) {
  console.error("Usage: node probe-mcp.mjs <command> [args...]");
  process.exit(2);
}

const VERSION = "2026-07-28";
const CLIENT_INFO = {
  name: "raw-stdio-probe",
  version: "1.0.0"
};
const CLIENT_CAPABILITIES = {};

const child = spawn(command, args, {
  stdio: ["pipe", "pipe", "inherit"],
  windowsHide: true
});

const pending = new Map();
let nextId = 0;
let protocolFailure = null;
let closing = false;

const closePromise = new Promise((resolve) => {
  child.once("close", (code, signal) => resolve({ code, signal }));
});

function requestMeta() {
  return {
    "io.modelcontextprotocol/protocolVersion": VERSION,
    "io.modelcontextprotocol/clientInfo": CLIENT_INFO,
    "io.modelcontextprotocol/clientCapabilities": CLIENT_CAPABILITIES
  };
}

function failProtocol(error) {
  if (!protocolFailure) protocolFailure = error;
  for (const entry of pending.values()) {
    clearTimeout(entry.timer);
    entry.reject(error);
  }
  pending.clear();
}

child.on("error", (error) => {
  failProtocol(new Error("Failed to start server: " + error.message));
});

child.stdin.on("error", (error) => {
  if (!closing) {
    failProtocol(new Error("Failed to write to server stdin: " + error.message));
  }
});

child.on("exit", (code, signal) => {
  if (!closing && pending.size > 0) {
    failProtocol(
      new Error(
        "Server exited with code=" + String(code) +
        " signal=" + String(signal)
      )
    );
  }
});

const lines = createInterface({
  input: child.stdout,
  crlfDelay: Infinity
});

lines.on("line", (line) => {
  if (line.length === 0) {
    failProtocol(new Error("Blank line on server stdout"));
    return;
  }

  let message;
  try {
    message = JSON.parse(line);
  } catch {
    failProtocol(
      new Error("Non-JSON data on server stdout: " + JSON.stringify(line))
    );
    return;
  }

  if (
    message === null ||
    typeof message !== "object" ||
    Array.isArray(message)
  ) {
    failProtocol(new Error("JSON-RPC message must be an object"));
    return;
  }

  if (message.jsonrpc !== "2.0") {
    failProtocol(new Error("jsonrpc must be exactly 2.0"));
    return;
  }

  const hasId = Object.hasOwn(message, "id");
  const hasMethod = Object.hasOwn(message, "method");
  const hasResult = Object.hasOwn(message, "result");
  const hasError = Object.hasOwn(message, "error");

  if (!hasId) {
    const hasInvalidParams =
      Object.hasOwn(message, "params") &&
      (
        message.params === null ||
        typeof message.params !== "object" ||
        Array.isArray(message.params)
      );

    if (
      typeof message.method !== "string" ||
      hasResult ||
      hasError ||
      hasInvalidParams
    ) {
      failProtocol(new Error("Invalid JSON-RPC notification"));
      return;
    }

    console.error("Server notification:", JSON.stringify(message));
    return;
  }

  if (hasMethod) {
    failProtocol(new Error("Server must not send JSON-RPC requests over stdio"));
    return;
  }

  if (typeof message.id !== "string" && typeof message.id !== "number") {
    failProtocol(new Error("Response id must be a string or number"));
    return;
  }

  const key = typeof message.id + ":" + String(message.id);
  const entry = pending.get(key);
  if (!entry) {
    failProtocol(
      new Error("Unexpected response id: " + JSON.stringify(message.id))
    );
    return;
  }

  if (hasResult === hasError) {
    failProtocol(
      new Error("Response must contain exactly one of result or error")
    );
    return;
  }

  if (hasError) {
    if (
      message.error === null ||
      typeof message.error !== "object" ||
      Array.isArray(message.error) ||
      !Number.isInteger(message.error.code) ||
      typeof message.error.message !== "string"
    ) {
      failProtocol(new Error("Invalid JSON-RPC error object"));
      return;
    }
  }

  pending.delete(key);
  clearTimeout(entry.timer);

  if (hasError) {
    const error = new Error("JSON-RPC error: " + JSON.stringify(message.error));
    error.rpcError = message.error;
    entry.reject(error);
    return;
  }

  entry.resolve(message.result);
});

function request(method, params = {}, timeoutMs = 5000) {
  if (protocolFailure) return Promise.reject(protocolFailure);
  if (child.stdin.destroyed || !child.stdin.writable) {
    return Promise.reject(new Error("Server stdin is not writable"));
  }

  const id = "probe-" + String(++nextId);
  const key = typeof id + ":" + id;
  const message = {
    jsonrpc: "2.0",
    id,
    method,
    params: {
      ...params,
      _meta: requestMeta()
    }
  };

  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      pending.delete(key);
      reject(new Error("Timed out waiting for " + method));
    }, timeoutMs);

    pending.set(key, { resolve, reject, timer });
    child.stdin.write(JSON.stringify(message) + "\n", (error) => {
      if (!error) return;

      const current = pending.get(key);
      if (!current) return;

      pending.delete(key);
      clearTimeout(current.timer);
      current.reject(
        new Error("Failed to write " + method + ": " + error.message)
      );
    });
  });
}

async function waitForExit(timeoutMs) {
  let timer;
  try {
    return await Promise.race([
      closePromise,
      new Promise((resolve) => {
        timer = setTimeout(() => resolve(null), timeoutMs);
      })
    ]);
  } finally {
    clearTimeout(timer);
  }
}

async function stopServer() {
  closing = true;
  if (!child.stdin.destroyed && !child.stdin.writableEnded) child.stdin.end();

  let exited = await waitForExit(2000);
  if (exited) return { ...exited, forced: false };

  try {
    child.kill();
  } catch (error) {
    throw new Error("Failed to terminate server: " + error.message);
  }

  exited = await waitForExit(2000);
  if (!exited) {
    throw new Error("Server did not exit after forced termination");
  }

  return { ...exited, forced: true };
}

async function main() {
  const discovery = await request("server/discover");
  if (discovery.resultType !== "complete") {
    throw new Error("Discovery did not complete");
  }
  if (
    !Array.isArray(discovery.supportedVersions) ||
    !discovery.supportedVersions.includes(VERSION)
  ) {
    throw new Error(
      "Server does not advertise target version " + VERSION
    );
  }

  console.log(
    "Discovery:",
    JSON.stringify(
      {
        supportedVersions: discovery.supportedVersions,
        capabilities: discovery.capabilities
      },
      null,
      2
    )
  );

  if (!Object.hasOwn(discovery.capabilities ?? {}, "tools")) {
    console.log("Server does not advertise the tools capability.");
    return;
  }

  const listed = await request("tools/list");
  if (listed.resultType !== "complete" || !Array.isArray(listed.tools)) {
    throw new Error("Invalid tools/list result");
  }
  if (
    Object.hasOwn(listed, "nextCursor") &&
    typeof listed.nextCursor !== "string"
  ) {
    throw new Error("Invalid tools/list nextCursor");
  }

  console.log(
    "Tools:",
    JSON.stringify(
      listed.tools.map((tool) => ({
        name: tool.name,
        hasInputSchema: Boolean(tool.inputSchema),
        hasOutputSchema: Boolean(tool.outputSchema)
      })),
      null,
      2
    )
  );

  if (Object.hasOwn(listed, "nextCursor")) {
    console.log(
      "More tools are available. This minimal probe prints only the first page."
    );
  }
}

let testFailed = false;
try {
  await main();
} catch (error) {
  testFailed = true;
  console.error(error.stack ?? error.message);
  process.exitCode = 1;
} finally {
  try {
    const shutdown = await stopServer();
    if (!testFailed && protocolFailure) throw protocolFailure;
    if (
      !testFailed &&
      (shutdown.forced || shutdown.code !== 0 || shutdown.signal !== null)
    ) {
      throw new Error(
        "Abnormal server shutdown: code=" + String(shutdown.code) +
        " signal=" + String(shutdown.signal) +
        " forced=" + String(shutdown.forced)
      );
    }
  } catch (error) {
    console.error(error.stack ?? error.message);
    process.exitCode = 1;
  }
}

{
  "jsonrpc": "2.0",
  "id": "init-1",
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-11-25",
    "capabilities": {},
    "clientInfo": {
      "name": "raw-stdio-probe",
      "version": "1.0.0"
    }
  }
}

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized",
  "params": {}
}