@aiwerk/mcp-bridge 1.0.0

package/tests/mcp-router.test.ts

@@ -0,0 +1,301 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { McpRouter } from "../src/mcp-router.ts";
+import type { McpRequest, McpResponse, McpServerConfig, McpTransport, McpTool } from "../src/types.ts";
+
+type Behavior = {
+  tools: McpTool[];
+  callResult?: any;
+  callError?: { code: number; message: string };
+  connectError?: Error;
+};
+
+class MockTransport implements McpTransport {
+  static behaviors = new Map<string, Behavior>();
+  static instances = new Map<string, MockTransport>();
+
+  static reset(): void {
+    this.behaviors.clear();
+    this.instances.clear();
+  }
+
+  connected = false;
+  requests: McpRequest[] = [];
+  connectCount = 0;
+  disconnectCount = 0;
+  private readonly key: string;
+
+  constructor(config: McpServerConfig, _clientConfig?: any, _logger?: any, _onReconnected?: () => Promise<void>) {
+    this.key = config.url || config.command || "default";
+    MockTransport.instances.set(this.key, this);
+  }
+
+  async connect(): Promise<void> {
+    this.connectCount += 1;
+    const behavior = MockTransport.behaviors.get(this.key);
+    if (behavior?.connectError) {
+      throw behavior.connectError;
+    }
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.disconnectCount += 1;
+    this.connected = false;
+  }
+
+  async sendRequest(request: McpRequest): Promise<McpResponse> {
+    this.requests.push(request);
+    const behavior = MockTransport.behaviors.get(this.key);
+
+    if (request.method === "initialize") {
+      return { jsonrpc: "2.0", id: 1, result: {} };
+    }
+
+    if (request.method === "tools/list") {
+      return { jsonrpc: "2.0", id: 2, result: { tools: behavior?.tools || [] } };
+    }
+
+    if (request.method === "tools/call") {
+      if (behavior?.callError) {
+        return {
+          jsonrpc: "2.0",
+          id: 3,
+          error: {
+            code: behavior.callError.code,
+            message: behavior.callError.message
+          }
+        };
+      }
+      return { jsonrpc: "2.0", id: 3, result: behavior?.callResult || { ok: true } };
+    }
+
+    return { jsonrpc: "2.0", id: 4, result: {} };
+  }
+
+  async sendNotification(_notification: any): Promise<void> {
+    return;
+  }
+
+  isConnected(): boolean {
+    return this.connected;
+  }
+}
+
+function makeLogger() {
+  return {
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    debug: () => {}
+  };
+}
+
+function makeRouter(
+  servers: Record<string, McpServerConfig>,
+  overrides: { routerIdleTimeoutMs?: number; routerMaxConcurrent?: number } = {}
+): McpRouter {
+  return new McpRouter(
+    servers,
+    {
+      servers,
+      routerIdleTimeoutMs: overrides.routerIdleTimeoutMs,
+      routerMaxConcurrent: overrides.routerMaxConcurrent
+    },
+    makeLogger(),
+    {
+      sse: MockTransport,
+      stdio: MockTransport,
+      streamableHttp: MockTransport
+    }
+  );
+}
+
+test.beforeEach(() => {
+  MockTransport.reset();
+});
+
+test("dispatch returns unknown_server error for missing server", async () => {
+  const router = makeRouter({
+    alpha: { transport: "sse", url: "mock://alpha" }
+  });
+
+  const result = await router.dispatch("missing", "list");
+  assert.equal("error" in result ? result.error : "", "unknown_server");
+});
+
+test("dispatch action=list returns cached tool list", async () => {
+  const server = { transport: "sse" as const, url: "mock://cache" };
+  MockTransport.behaviors.set("mock://cache", {
+    tools: [
+      {
+        name: "create_server",
+        description: "Create server",
+        inputSchema: {
+          type: "object",
+          properties: { name: { type: "string" } },
+          required: ["name"]
+        }
+      }
+    ]
+  });
+
+  const router = makeRouter({ cache: server });
+  const first = await router.dispatch("cache", "list");
+  const second = await router.dispatch("cache", "list");
+
+  assert.equal("error" in first, false);
+  assert.equal("error" in second, false);
+  if (!("error" in first) && first.action === "list") {
+    assert.deepEqual(first.tools, [
+      {
+        name: "create_server",
+        description: "Create server",
+        requiredParams: ["name"]
+      }
+    ]);
+  }
+
+  const instance = MockTransport.instances.get("mock://cache");
+  assert.ok(instance);
+  const listCalls = instance!.requests.filter((req) => req.method === "tools/list");
+  assert.equal(listCalls.length, 1);
+});
+
+test("dispatch action=call proxies to transport", async () => {
+  MockTransport.behaviors.set("mock://call", {
+    tools: [{ name: "list_servers", description: "List", inputSchema: { type: "object" } }],
+    callResult: { servers: [{ id: "1" }] }
+  });
+
+  const router = makeRouter({
+    call: { transport: "sse", url: "mock://call" }
+  });
+
+  const result = await router.dispatch("call", "call", "list_servers", { region: "eu-central" });
+  assert.equal("error" in result, false);
+  if (!("error" in result) && result.action === "call") {
+    assert.deepEqual(result.result, { servers: [{ id: "1" }] });
+  }
+
+  const instance = MockTransport.instances.get("mock://call");
+  assert.ok(instance);
+  const callRequest = instance!.requests.find((req) => req.method === "tools/call");
+  assert.ok(callRequest);
+  assert.deepEqual(callRequest!.params, {
+    name: "list_servers",
+    arguments: { region: "eu-central" }
+  });
+});
+
+test("evicts least recently used connection when max concurrent exceeded", async () => {
+  const servers = {
+    a: { transport: "sse" as const, url: "mock://a" },
+    b: { transport: "sse" as const, url: "mock://b" },
+    c: { transport: "sse" as const, url: "mock://c" }
+  };
+
+  for (const key of Object.keys(servers)) {
+    MockTransport.behaviors.set(`mock://${key}`, {
+      tools: [{ name: "ping", description: "Ping", inputSchema: { type: "object" } }]
+    });
+  }
+
+  const router = makeRouter(servers, { routerMaxConcurrent: 2, routerIdleTimeoutMs: 60_000 });
+
+  await router.dispatch("a", "list");
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  await router.dispatch("b", "list");
+  await new Promise((resolve) => setTimeout(resolve, 5));
+  await router.dispatch("c", "list");
+
+  assert.equal(MockTransport.instances.get("mock://a")?.disconnectCount, 1);
+  assert.equal(MockTransport.instances.get("mock://b")?.isConnected(), true);
+  assert.equal(MockTransport.instances.get("mock://c")?.isConnected(), true);
+});
+
+test("disconnects idle connection after timeout", async () => {
+  MockTransport.behaviors.set("mock://idle", {
+    tools: [{ name: "ping", description: "Ping", inputSchema: { type: "object" } }]
+  });
+
+  const router = makeRouter(
+    { idle: { transport: "sse", url: "mock://idle" } },
+    { routerIdleTimeoutMs: 25, routerMaxConcurrent: 5 }
+  );
+
+  await router.dispatch("idle", "list");
+  await new Promise((resolve) => setTimeout(resolve, 80));
+
+  const instance = MockTransport.instances.get("mock://idle");
+  assert.ok(instance);
+  assert.equal(instance!.disconnectCount >= 1, true);
+  assert.equal(instance!.isConnected(), false);
+});
+
+test("generateDescription includes configured servers", () => {
+  const description = McpRouter.generateDescription({
+    hetzner: { transport: "sse", url: "mock://h" },
+    github: { transport: "sse", url: "mock://g" }
+  });
+
+  assert.match(description, /hetzner/);
+  assert.match(description, /github/);
+  assert.match(description, /action='list'/);
+  assert.match(description, /action='call'/);
+  assert.match(description, /action='refresh'/);
+});
+
+test("status action returns all servers with connection state", async () => {
+  const servers = {
+    alpha: { transport: "stdio" as const, command: "node", args: ["fake.js"] },
+    beta: { transport: "sse" as const, url: "http://localhost:9999/sse" }
+  };
+  const router = makeRouter(servers);
+
+  const result = await router.dispatch(undefined, "status");
+  assert.equal("action" in result && result.action, "status");
+  if ("servers" in result) {
+    assert.equal(result.servers.length, 2);
+    const alpha = result.servers.find(s => s.name === "alpha");
+    assert.ok(alpha);
+    assert.equal(alpha!.status, "disconnected");
+    assert.equal(alpha!.tools, 0);
+    assert.equal(alpha!.transport, "stdio");
+    const beta = result.servers.find(s => s.name === "beta");
+    assert.ok(beta);
+    assert.equal(beta!.status, "disconnected");
+    assert.equal(beta!.transport, "sse");
+  }
+});
+
+test("status action shows connected server after list", async () => {
+  const servers = {
+    alpha: { transport: "stdio" as const, command: "node", args: ["fake.js"] }
+  };
+  MockTransport.behaviors.set("node", {
+    tools: [
+      { name: "tool_a", description: "A", inputSchema: { type: "object" } },
+      { name: "tool_b", description: "B", inputSchema: { type: "object" } }
+    ]
+  });
+  const router = makeRouter(servers);
+
+  // List triggers connection + tool fetch
+  await router.dispatch("alpha", "list");
+
+  const result = await router.dispatch(undefined, "status");
+  if ("servers" in result) {
+    const alpha = result.servers.find(s => s.name === "alpha");
+    assert.ok(alpha);
+    assert.equal(alpha!.status, "connected");
+    assert.equal(alpha!.tools, 2);
+  }
+});
+
+test("generateDescription includes status action", () => {
+  const description = McpRouter.generateDescription({
+    test: { transport: "stdio", command: "node", args: [] }
+  });
+  assert.match(description, /action='status'/);
+});

package/tests/schema-convert.test.ts

@@ -0,0 +1,70 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  convertJsonSchemaToTypeBox,
+  createToolParameters,
+  setTypeBoxLoader
+} from "../src/schema-convert.ts";
+
+test("converts string schema", async () => {
+  const schema = await convertJsonSchemaToTypeBox({ type: "string", minLength: 1 });
+  assert.equal(schema.type, "string");
+  assert.equal(schema.minLength, 1);
+});
+
+test("converts number schema", async () => {
+  const schema = await convertJsonSchemaToTypeBox({ type: "number", minimum: 2, maximum: 5 });
+  assert.equal(schema.type, "number");
+  assert.equal(schema.minimum, 2);
+  assert.equal(schema.maximum, 5);
+});
+
+test("converts object schema", async () => {
+  const schema = await convertJsonSchemaToTypeBox({
+    type: "object",
+    properties: {
+      name: { type: "string" },
+      age: { type: "number" }
+    },
+    required: ["name"]
+  });
+
+  assert.equal(schema.type, "object");
+  assert.ok(schema.properties.name);
+  assert.ok(schema.properties.age);
+});
+
+test("converts array schema", async () => {
+  const schema = await convertJsonSchemaToTypeBox({ type: "array", items: { type: "string" } });
+  assert.equal(schema.type, "array");
+  assert.equal(schema.items.type, "string");
+});
+
+test("converts anyOf schema", async () => {
+  const schema = await convertJsonSchemaToTypeBox({
+    anyOf: [{ type: "string" }, { type: "number" }]
+  });
+
+  assert.ok(Array.isArray(schema.anyOf));
+  assert.equal(schema.anyOf.length, 2);
+  assert.equal(schema.anyOf[0].type, "string");
+  assert.equal(schema.anyOf[1].type, "number");
+});
+
+test("falls back when TypeBox is missing", async () => {
+  // Inject a loader that simulates missing TypeBox
+  setTypeBoxLoader(async () => null);
+
+  try {
+    const schema = await convertJsonSchemaToTypeBox({ type: "string" });
+    const params = await createToolParameters({ type: "object" });
+
+    // convertJsonSchemaToTypeBox fallback: empty schema {}
+    assert.deepStrictEqual(schema, {});
+    // createToolParameters fallback: returns raw inputSchema as-is
+    assert.deepStrictEqual(params, { type: "object" });
+  } finally {
+    // Restore default loader
+    setTypeBoxLoader(null);
+  }
+});

package/tests/transport-base.test.ts

@@ -0,0 +1,214 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { BaseTransport } from "../src/transport-base.ts";
+import type { McpRequest, McpResponse, McpServerConfig } from "../src/types.ts";
+
+class TestableTransport extends BaseTransport {
+  protected get transportName(): string {
+    return "test";
+  }
+
+  async connect(): Promise<void> {
+    this.connected = true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.connected = false;
+  }
+
+  async sendRequest(_request: McpRequest): Promise<McpResponse> {
+    return { jsonrpc: "2.0", id: 0, result: {} };
+  }
+
+  async sendNotification(_notification: any): Promise<void> {
+    return;
+  }
+
+  testHandleMessage(message: any): void {
+    this.handleMessage(message);
+  }
+
+  testScheduleReconnect(): void {
+    this.scheduleReconnect();
+  }
+
+  testRejectAllPending(reason: string): void {
+    this.rejectAllPending(reason);
+  }
+
+  testCleanupReconnectTimer(): void {
+    this.cleanupReconnectTimer();
+  }
+
+  getPendingRequests() {
+    return this.pendingRequests;
+  }
+
+  setConnected(value: boolean): void {
+    this.connected = value;
+  }
+
+  getReconnectTimer() {
+    return this.reconnectTimer;
+  }
+}
+
+function makeLogger() {
+  return {
+    debugCalls: [] as string[],
+    errorCalls: [] as any[],
+    infoCalls: [] as string[],
+    debug(msg: string) {
+      this.debugCalls.push(msg);
+    },
+    error(...args: any[]) {
+      this.errorCalls.push(args);
+    },
+    info(msg: string) {
+      this.infoCalls.push(msg);
+    },
+  };
+}
+
+function makeTransport(onReconnected?: () => Promise<void>) {
+  const config: McpServerConfig = { transport: "sse", url: "http://localhost:1234/sse" };
+  const clientConfig = { reconnectIntervalMs: 10_000 };
+  const logger = makeLogger();
+  const transport = new TestableTransport(config, clientConfig, logger, onReconnected);
+  return { transport, logger };
+}
+
+test("handleMessage resolves pending request when response.id matches", async () => {
+  const { transport } = makeTransport();
+
+  let resolved: any;
+  const promise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timeout")), 1000);
+    transport.getPendingRequests().set(1, { resolve, reject, timeout });
+  });
+
+  transport.testHandleMessage({ jsonrpc: "2.0", id: 1, result: { ok: true } });
+
+  resolved = await promise;
+  assert.deepEqual(resolved, { jsonrpc: "2.0", id: 1, result: { ok: true } });
+  assert.equal(transport.getPendingRequests().size, 0);
+});
+
+test("handleMessage rejects pending request when response has error", async () => {
+  const { transport } = makeTransport();
+
+  const promise = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timeout")), 1000);
+    transport.getPendingRequests().set(2, { resolve, reject, timeout });
+  });
+
+  transport.testHandleMessage({ jsonrpc: "2.0", id: 2, error: { code: -1, message: "boom" } });
+
+  await assert.rejects(promise, /boom/);
+  assert.equal(transport.getPendingRequests().size, 0);
+});
+
+test("handleMessage ignores messages with unknown id (no crash)", () => {
+  const { transport } = makeTransport();
+
+  assert.doesNotThrow(() => {
+    transport.testHandleMessage({ jsonrpc: "2.0", id: 999, result: { ok: true } });
+  });
+
+  assert.equal(transport.getPendingRequests().size, 0);
+});
+
+test("handleMessage calls onReconnected on notifications/tools/list_changed", async () => {
+  let called = 0;
+  const { transport } = makeTransport(async () => {
+    called += 1;
+  });
+
+  transport.testHandleMessage({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(called, 1);
+});
+
+test("handleMessage logs debug for unknown notifications", () => {
+  const { transport, logger } = makeTransport();
+
+  assert.doesNotThrow(() => {
+    transport.testHandleMessage({ jsonrpc: "2.0", method: "notifications/other" });
+  });
+
+  assert.equal(logger.debugCalls.length, 1);
+  assert.match(logger.debugCalls[0], /Unhandled test notification: notifications\/other/);
+});
+
+test("rejectAllPending rejects all pending and clears the map", async () => {
+  const { transport } = makeTransport();
+
+  const p1 = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timeout")), 1000);
+    transport.getPendingRequests().set(1, { resolve, reject, timeout });
+  });
+  const p2 = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timeout")), 1000);
+    transport.getPendingRequests().set(2, { resolve, reject, timeout });
+  });
+
+  transport.testRejectAllPending("cancelled");
+
+  await assert.rejects(p1, /cancelled/);
+  await assert.rejects(p2, /cancelled/);
+  assert.equal(transport.getPendingRequests().size, 0);
+});
+
+test("rejectAllPending with empty map doesn't crash", () => {
+  const { transport } = makeTransport();
+
+  assert.doesNotThrow(() => {
+    transport.testRejectAllPending("anything");
+  });
+
+  assert.equal(transport.getPendingRequests().size, 0);
+});
+
+test("scheduleReconnect sets connected=false and rejects pending", async () => {
+  const { transport } = makeTransport();
+  transport.setConnected(true);
+
+  const pending = new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("timeout")), 1000);
+    transport.getPendingRequests().set(10, { resolve, reject, timeout });
+  });
+
+  transport.testScheduleReconnect();
+
+  assert.equal(transport.isConnected(), false);
+  await assert.rejects(pending, /Connection lost, request cancelled/);
+  assert.equal(transport.getPendingRequests().size, 0);
+
+  transport.testCleanupReconnectTimer();
+});
+
+test("scheduleReconnect doesn't schedule twice (idempotent)", () => {
+  const { transport } = makeTransport();
+
+  transport.testScheduleReconnect();
+  const firstTimer = transport.getReconnectTimer();
+
+  transport.testScheduleReconnect();
+  const secondTimer = transport.getReconnectTimer();
+
+  assert.ok(firstTimer);
+  assert.equal(firstTimer, secondTimer);
+
+  transport.testCleanupReconnectTimer();
+});
+
+test("cleanupReconnectTimer clears the timer", () => {
+  const { transport } = makeTransport();
+
+  transport.testScheduleReconnect();
+  assert.ok(transport.getReconnectTimer());
+
+  transport.testCleanupReconnectTimer();
+  assert.equal(transport.getReconnectTimer(), null);
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true
+  },
+  "include": ["src/**/*.ts", "bin/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}