@aiwerk/mcp-bridge 1.0.0 → 1.0.2

package/src/update-checker.ts

@@ -1,155 +0,0 @@
-import { execSync, exec as execCb } from "child_process";
-import { Logger } from "./types.js";
-import { PACKAGE_VERSION } from "./protocol.js";
-
-export interface UpdateInfo {
-  currentVersion: string;
-  latestVersion: string;
-  updateAvailable: boolean;
-  updateCommand: string;
-}
-
-const PACKAGE_NAME = "@aiwerk/mcp-bridge";
-
-let cachedUpdateInfo: UpdateInfo | null = null;
-let noticeDelivered = false;
-
-/**
- * Check npm registry for a newer version. Non-blocking, best-effort.
- * Caches result for the lifetime of the process.
- */
-export async function checkForUpdate(logger: Logger): Promise<UpdateInfo> {
-  if (cachedUpdateInfo) return cachedUpdateInfo;
-
-  const current = PACKAGE_VERSION;
-  const updateCmd = `npm update -g ${PACKAGE_NAME}`;
-
-  try {
-    const latest = await npmViewVersion(logger);
-    const updateAvailable = latest !== current && isNewer(latest, current);
-
-    cachedUpdateInfo = {
-      currentVersion: current,
-      latestVersion: latest,
-      updateAvailable,
-      updateCommand: updateCmd,
-    };
-
-    if (updateAvailable) {
-      logger.info(`[mcp-bridge] Update available: ${current} → ${latest}`);
-    } else {
-      logger.info(`[mcp-bridge] Version ${current} is up to date`);
-    }
-  } catch (err) {
-    logger.warn(`[mcp-bridge] Version check failed: ${err instanceof Error ? err.message : err}`);
-    cachedUpdateInfo = {
-      currentVersion: current,
-      latestVersion: current,
-      updateAvailable: false,
-      updateCommand: updateCmd,
-    };
-  }
-
-  return cachedUpdateInfo;
-}
-
-/**
- * Build the notice string to inject into the first tool response.
- * Returns empty string if no update or already delivered.
- */
-export function getUpdateNotice(): string {
-  if (noticeDelivered || !cachedUpdateInfo?.updateAvailable) return "";
-  noticeDelivered = true;
-  return (
-    `\n\n---\nUpdate available: ${cachedUpdateInfo.currentVersion} → ${cachedUpdateInfo.latestVersion}\n` +
-    `Run: ${cachedUpdateInfo.updateCommand}`
-  );
-}
-
-/**
- * Reset the notice flag (for testing).
- */
-export function resetNoticeFlag(): void {
-  noticeDelivered = false;
-}
-
-/**
- * Execute the actual npm update. Returns a result message.
- */
-export async function runUpdate(logger: Logger): Promise<string> {
-  const info = cachedUpdateInfo ?? await checkForUpdate(logger);
-
-  if (!info.updateAvailable) {
-    return `MCP Bridge is already up to date (v${info.currentVersion}).`;
-  }
-
-  logger.info(`[mcp-bridge] Running update: ${info.updateCommand}`);
-
-  try {
-    const output = await execAsync(info.updateCommand, 60_000);
-    // Invalidate cache so next check re-fetches
-    cachedUpdateInfo = null;
-    noticeDelivered = false;
-
-    // Verify new version
-    const newVersion = npmViewVersionSync(logger);
-    return (
-      `MCP Bridge updated: ${info.currentVersion} → ${newVersion}\n` +
-      `A restart is needed to load the new version.\n\n` +
-      `npm output:\n${output.trim()}`
-    );
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logger.error(`[mcp-bridge] Update failed: ${msg}`);
-    return (
-      `Update failed. You can try manually:\n` +
-      `${info.updateCommand}\n\nError: ${msg}`
-    );
-  }
-}
-
-// --- helpers ---
-
-function npmViewVersion(_logger: Logger): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error("npm view timed out")), 10_000);
-    execCb(`npm view ${PACKAGE_NAME} version`, { encoding: "utf-8" }, (err, stdout) => {
-      clearTimeout(timeout);
-      if (err) return reject(err);
-      const ver = (stdout ?? "").trim();
-      if (!ver) return reject(new Error("empty version from npm"));
-      resolve(ver);
-    });
-  });
-}
-
-function npmViewVersionSync(_logger: Logger): string {
-  try {
-    return execSync(`npm view ${PACKAGE_NAME} version`, { encoding: "utf-8", timeout: 10_000 }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-
-function execAsync(cmd: string, timeoutMs: number): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)), timeoutMs);
-    execCb(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout, stderr) => {
-      clearTimeout(timeout);
-      if (err) return reject(new Error(`${err.message}\n${stderr ?? ""}`));
-      resolve(stdout ?? "");
-    });
-  });
-}
-
-function isNewer(latest: string, current: string): boolean {
-  const l = latest.split(".").map(Number);
-  const c = current.split(".").map(Number);
-  for (let i = 0; i < Math.max(l.length, c.length); i++) {
-    const lv = l[i] ?? 0;
-    const cv = c[i] ?? 0;
-    if (lv > cv) return true;
-    if (lv < cv) return false;
-  }
-  return false;
-}

package/tests/collision.test.ts

@@ -1,60 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { pickRegisteredToolName } from "../src/tool-naming.ts";
-
-test("auto mode: collision causes second server tool to be prefixed", () => {
-  const globalNames = new Set<string>();
-
-  // "auto" (default) — no prefix unless collision
-  const first = pickRegisteredToolName("alpha", "search", "auto", new Set<string>(), globalNames);
-  globalNames.add(first);
-
-  const second = pickRegisteredToolName("beta", "search", "auto", new Set<string>(), globalNames);
-
-  assert.equal(first, "search");
-  assert.equal(second, "beta_search");
-});
-
-test("auto mode: no collision means no prefix", () => {
-  const globalNames = new Set<string>();
-
-  const first = pickRegisteredToolName("alpha", "search", "auto", new Set<string>(), globalNames);
-  globalNames.add(first);
-
-  const second = pickRegisteredToolName("beta", "list", "auto", new Set<string>(), globalNames);
-
-  assert.equal(first, "search");
-  assert.equal(second, "list");
-});
-
-test("auto mode: undefined defaults to auto", () => {
-  const globalNames = new Set<string>();
-
-  const first = pickRegisteredToolName("alpha", "search", undefined, new Set<string>(), globalNames);
-  globalNames.add(first);
-
-  const second = pickRegisteredToolName("beta", "search", undefined, new Set<string>(), globalNames);
-
-  assert.equal(first, "search");
-  assert.equal(second, "beta_search");
-});
-
-test("true mode: always prefixes", () => {
-  const globalNames = new Set<string>();
-
-  const name = pickRegisteredToolName("alpha", "search", true, new Set<string>(), globalNames);
-
-  assert.equal(name, "alpha_search");
-});
-
-test("false mode: never prefixes, uses suffix on collision", () => {
-  const globalNames = new Set<string>();
-
-  const first = pickRegisteredToolName("alpha", "search", false, new Set<string>(), globalNames);
-  globalNames.add(first);
-
-  const second = pickRegisteredToolName("beta", "search", false, new Set<string>(), globalNames);
-
-  assert.equal(first, "search");
-  assert.equal(second, "search_2");
-});

package/tests/env-resolve.test.ts

@@ -1,68 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { resolveEnvVars, resolveEnvRecord, resolveArgs } from "../src/transport-base.ts";
-
-test("resolveEnvRecord throws when env var is missing", () => {
-  assert.throws(
-    () => resolveEnvRecord({ TOKEN: "${MISSING_TEST_ENV}" }, "env key"),
-    /Missing required environment variable/
-  );
-});
-
-test("resolveArgs resolves env vars in args", () => {
-  const env = { MY_TOKEN: "secret123" };
-  const result = resolveArgs(["--token", "${MY_TOKEN}", "--verbose"], env);
-  assert.deepStrictEqual(result, ["--token", "secret123", "--verbose"]);
-});
-
-test("resolveArgs throws when env var is missing in args", () => {
-  assert.throws(
-    () => resolveArgs(["--token", "${MISSING_TEST_ENV}"], {}),
-    /Missing required environment variable/
-  );
-});
-
-test("resolveArgs passes through args without variables", () => {
-  const result = resolveArgs(["-y", "@llmindset/mcp-miro", "--verbose"], {});
-  assert.deepStrictEqual(result, ["-y", "@llmindset/mcp-miro", "--verbose"]);
-});
-
-test("resolveEnvRecord resolves headers with env vars", () => {
-  process.env.__TEST_MCP_TOKEN = "test-secret-456";
-  try {
-    const result = resolveEnvRecord(
-      { Authorization: "Bearer ${__TEST_MCP_TOKEN}" },
-      "header"
-    );
-    assert.deepStrictEqual(result, { Authorization: "Bearer test-secret-456" });
-  } finally {
-    delete process.env.__TEST_MCP_TOKEN;
-  }
-});
-
-test("resolveEnvRecord throws for missing header env var", () => {
-  assert.throws(
-    () => resolveEnvRecord({ Authorization: "Bearer ${MISSING_TEST_ENV}" }, "header"),
-    /Missing required environment variable/
-  );
-});
-
-test("resolveEnvVars resolves single value", () => {
-  process.env.__TEST_MCP_SINGLE = "hello";
-  try {
-    const result = resolveEnvVars("prefix-${__TEST_MCP_SINGLE}-suffix", "test");
-    assert.equal(result, "prefix-hello-suffix");
-  } finally {
-    delete process.env.__TEST_MCP_SINGLE;
-  }
-});
-
-test("resolveEnvVars uses extraEnv before process.env", () => {
-  process.env.__TEST_MCP_PRIO = "from-process";
-  try {
-    const result = resolveEnvVars("${__TEST_MCP_PRIO}", "test", { __TEST_MCP_PRIO: "from-extra" });
-    assert.equal(result, "from-extra");
-  } finally {
-    delete process.env.__TEST_MCP_PRIO;
-  }
-});

package/tests/mcp-router.test.ts

@@ -1,301 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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);
-  }
-});