136 lines
3.2 KiB
TypeScript
136 lines
3.2 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import {
|
|
inferTransport,
|
|
normalizeSharedMcpServer,
|
|
toClaudeServerConfig,
|
|
toCodexServerConfig,
|
|
} from "../src/mcp/converters.js";
|
|
import { parseMcpConfig } from "../src/mcp/types.js";
|
|
|
|
test("infers stdio transport when url is absent", () => {
|
|
const transport = inferTransport({
|
|
command: "npx",
|
|
args: ["-y", "@modelcontextprotocol/server-memory"],
|
|
});
|
|
assert.equal(transport, "stdio");
|
|
});
|
|
|
|
test("infers http transport when url is present", () => {
|
|
const transport = inferTransport({
|
|
url: "http://localhost:3000/mcp",
|
|
});
|
|
assert.equal(transport, "http");
|
|
});
|
|
|
|
test("throws for stdio codex server without command", () => {
|
|
assert.throws(
|
|
() => toCodexServerConfig("bad-server", { type: "stdio" }),
|
|
/requires "command" for stdio transport/,
|
|
);
|
|
});
|
|
|
|
test("maps shared headers to codex http_headers", () => {
|
|
const codexConfig = toCodexServerConfig("headers-server", {
|
|
url: "http://localhost:3000/mcp",
|
|
headers: {
|
|
Authorization: "Bearer token",
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(codexConfig.http_headers, {
|
|
Authorization: "Bearer token",
|
|
});
|
|
});
|
|
|
|
test("normalizes header aliases into a single headers object", () => {
|
|
const normalized = normalizeSharedMcpServer({
|
|
url: "http://localhost:3000/mcp",
|
|
http_headers: {
|
|
"X-Source": "legacy",
|
|
},
|
|
headers: {
|
|
Authorization: "Bearer token",
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(normalized.headers, {
|
|
"X-Source": "legacy",
|
|
Authorization: "Bearer token",
|
|
});
|
|
assert.equal("http_headers" in normalized, false);
|
|
});
|
|
|
|
test("maps legacy http_headers alias for claude conversion", () => {
|
|
const claudeConfig = toClaudeServerConfig("legacy-http-headers", {
|
|
type: "http",
|
|
url: "http://localhost:3000/mcp",
|
|
http_headers: {
|
|
Authorization: "Bearer token",
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(claudeConfig, {
|
|
type: "http",
|
|
url: "http://localhost:3000/mcp",
|
|
headers: {
|
|
Authorization: "Bearer token",
|
|
},
|
|
});
|
|
});
|
|
|
|
test("throws for claude http server without url", () => {
|
|
assert.throws(
|
|
() => toClaudeServerConfig("bad-http", { type: "http" }),
|
|
/requires "url" for http transport/,
|
|
);
|
|
});
|
|
|
|
test("maps sdk transport for claude conversion", () => {
|
|
const claudeConfig = toClaudeServerConfig("local-sdk", {
|
|
type: "sdk",
|
|
name: "local-sdk-server",
|
|
});
|
|
|
|
assert.deepEqual(claudeConfig, {
|
|
type: "sdk",
|
|
name: "local-sdk-server",
|
|
});
|
|
});
|
|
|
|
test("throws when sdk transport is converted for codex", () => {
|
|
assert.throws(
|
|
() => toCodexServerConfig("sdk-server", { type: "sdk", name: "sdk-server" }),
|
|
/not supported by Codex/,
|
|
);
|
|
});
|
|
|
|
test("accepts sdk transport in strict MCP schema", () => {
|
|
const parsed = parseMcpConfig({
|
|
servers: {
|
|
"sdk-server": {
|
|
type: "sdk",
|
|
name: "sdk-server",
|
|
},
|
|
},
|
|
});
|
|
|
|
assert.equal(parsed.servers?.["sdk-server"]?.type, "sdk");
|
|
});
|
|
|
|
test("rejects unknown fields in strict MCP schema", () => {
|
|
assert.throws(
|
|
() =>
|
|
parseMcpConfig({
|
|
servers: {
|
|
broken: {
|
|
type: "stdio",
|
|
command: "node",
|
|
extra: "nope",
|
|
},
|
|
},
|
|
}),
|
|
/unrecognized key/i,
|
|
);
|
|
});
|