@aiwerk/mcp-bridge 1.0.0 → 1.0.2

package/src/schema-convert.ts

@@ -1,178 +0,0 @@
-// TSchema is intentionally loose — TypeBox returns dynamic types
-// that don't have a single static interface
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type TSchema = any;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type TypeBoxMod = { Type: any } | null;
-
-let cachedTypeBoxPromise: Promise<TypeBoxMod> | null = null;
-
-// Overridable loader for dependency injection (used by tests)
-let typeBoxLoader: (() => Promise<TypeBoxMod>) | null = null;
-
-export function setTypeBoxLoader(loader: (() => Promise<TypeBoxMod>) | null): void {
-  typeBoxLoader = loader;
-  cachedTypeBoxPromise = null; // auto-reset cache
-}
-
-async function getTypeBox(): Promise<TypeBoxMod> {
-  // If a test loader is set, always use it (bypass cache)
-  if (typeBoxLoader) {
-    return typeBoxLoader();
-  }
-
-  if (cachedTypeBoxPromise) {
-    return cachedTypeBoxPromise;
-  }
-
-  cachedTypeBoxPromise = (async () => {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const mod: any = await import("@sinclair/typebox");
-      const Type = mod?.Type ?? mod?.default?.Type;
-      if (!Type) {
-        throw new Error("TypeBox module missing Type export");
-      }
-      return { Type };
-    } catch (error) {
-      return null;
-    }
-  })();
-
-  return cachedTypeBoxPromise;
-}
-
-
-
-async function anyFallback(): Promise<TSchema> {
-  const typeBox = await getTypeBox();
-  if (typeBox?.Type) {
-    return typeBox.Type.Any();
-  }
-  // Empty schema {} is valid JSON Schema (matches anything), unlike { type: "any" } which is invalid.
-  // This only triggers if @sinclair/typebox is missing — run `npm install` in the plugin directory.
-  schemaLogger.warn("[mcp-bridge] TypeBox unavailable — using permissive empty schema fallback. Run `npm install` to fix.");
-  return {};
-}
-
-// Logger can be injected via setSchemaLogger(); defaults to console
-let schemaLogger: { warn: (...args: unknown[]) => void } = console;
-export function setSchemaLogger(logger: { warn: (...args: unknown[]) => void }): void {
-  schemaLogger = logger;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function convertJsonSchemaToTypeBox(schema: any, depth = 0): Promise<TSchema> {
-  const typeBox = await getTypeBox();
-  const Type = typeBox?.Type;
-  if (!Type) {
-    return anyFallback();
-  }
-
-  try {
-    if (depth > 10) {
-      schemaLogger.warn("[mcp-bridge] JSON schema depth limit exceeded (>10), falling back to Type.Any()");
-      return Type.Any();
-    }
-
-    if (!schema || typeof schema !== "object") {
-      return Type.Any();
-    }
-
-    // anyOf and oneOf both map to Type.Union (TypeBox doesn't distinguish)
-    const unionSource = schema.anyOf || schema.oneOf;
-    if (Array.isArray(unionSource) && unionSource.length > 0) {
-      const variants = await Promise.all(
-        unionSource.map((item: Record<string, unknown>) => convertJsonSchemaToTypeBox(item, depth + 1))
-      );
-      return Type.Union(variants);
-    }
-
-    // allOf maps to Type.Intersect
-    if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-      const parts = await Promise.all(
-        schema.allOf.map((item: Record<string, unknown>) => convertJsonSchemaToTypeBox(item, depth + 1))
-      );
-      return Type.Intersect(parts);
-    }
-
-    switch (schema.type) {
-      case "string": {
-        if (schema.enum) {
-          return Type.Union(schema.enum.map((value: string) => Type.Literal(value)));
-        }
-        const stringOptions: Record<string, unknown> = {};
-        if (schema.minLength !== undefined) stringOptions.minLength = schema.minLength;
-        if (schema.maxLength !== undefined) stringOptions.maxLength = schema.maxLength;
-        if (schema.pattern !== undefined) stringOptions.pattern = schema.pattern;
-        return Type.String(stringOptions);
-      }
-      case "number":
-      case "integer": {
-        const numberOptions: Record<string, unknown> = {};
-        if (schema.minimum !== undefined) numberOptions.minimum = schema.minimum;
-        if (schema.maximum !== undefined) numberOptions.maximum = schema.maximum;
-        return Type.Number(numberOptions);
-      }
-      case "boolean":
-        return Type.Boolean();
-      case "array":
-        if (schema.items) {
-          return Type.Array(await convertJsonSchemaToTypeBox(schema.items, depth + 1));
-        }
-        return Type.Array(Type.Any());
-      case "object":
-        if (schema.properties) {
-          const propertyEntries = Object.entries(schema.properties);
-          if (propertyEntries.length > 100) {
-            schemaLogger.warn("[mcp-bridge] JSON schema object has too many properties (>100), falling back to Type.Any()");
-            return Type.Any();
-          }
-
-          const properties: Record<string, TSchema> = {};
-          const requiredSet = new Set<string>(
-            Array.isArray(schema.required) ? schema.required : []
-          );
-
-          for (const [key, value] of propertyEntries) {
-            const converted = await convertJsonSchemaToTypeBox(value as Record<string, unknown>, depth + 1);
-            properties[key] = requiredSet.has(key) ? converted : Type.Optional(converted);
-          }
-          return Type.Object(properties);
-        }
-        return Type.Object({});
-      case "null":
-        return Type.Null();
-      default:
-        return Type.Any();
-    }
-  } catch (error) {
-    schemaLogger.warn("[mcp-bridge] Failed to convert JSON schema, falling back to Type.Any()");
-    return Type.Any();
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function createToolParameters(inputSchema: any): Promise<TSchema> {
-  const typeBox = await getTypeBox();
-  const Type = typeBox?.Type;
-  if (!Type) {
-    // TypeBox missing — return the raw JSON Schema as-is
-    schemaLogger.warn("[mcp-bridge] TypeBox unavailable — passing raw JSON Schema. Run `npm install` to fix.");
-    return inputSchema ?? {};
-  }
-
-  if (!inputSchema) {
-    return Type.Object({});
-  }
-
-  // If the inputSchema is already a proper object schema, convert it
-  if (inputSchema.type === "object") {
-    return convertJsonSchemaToTypeBox(inputSchema, 0);
-  }
-
-  // If it's not an object, wrap it in an object
-  return Type.Object({
-    input: await convertJsonSchemaToTypeBox(inputSchema, 0)
-  });
-}

package/src/standalone-server.ts

@@ -1,385 +0,0 @@
-import { McpRouter } from "./mcp-router.js";
-import { fetchToolsList, initializeProtocol, PACKAGE_VERSION } from "./protocol.js";
-import { pickRegisteredToolName } from "./tool-naming.js";
-import {
-  BridgeConfig,
-  Logger,
-  McpRequest,
-  McpResponse,
-  McpServerConfig,
-  McpTool,
-  McpTransport,
-} from "./types.js";
-import { SseTransport } from "./transport-sse.js";
-import { StdioTransport } from "./transport-stdio.js";
-import { StreamableHttpTransport } from "./transport-streamable-http.js";
-
-interface DirectToolEntry {
-  serverName: string;
-  originalName: string;
-  registeredName: string;
-  description: string;
-  inputSchema: any;
-}
-
-/**
- * Standalone MCP server that wraps the router.
- * Implements the MCP protocol (initialize, tools/list, tools/call)
- * and forwards tool calls to backend MCP servers.
- */
-export class StandaloneServer {
-  private config: BridgeConfig;
-  private logger: Logger;
-  private router: McpRouter | null = null;
-  private initialized = false;
-
-  // Direct mode state
-  private directTools: DirectToolEntry[] = [];
-  private directConnections = new Map<string, { transport: McpTransport; initialized: boolean }>();
-
-  constructor(config: BridgeConfig, logger: Logger) {
-    this.config = config;
-    this.logger = logger;
-
-    if (this.isRouterMode()) {
-      this.router = new McpRouter(config.servers || {}, config, logger);
-    }
-  }
-
-  private isRouterMode(): boolean {
-    return (this.config.mode ?? "router") === "router";
-  }
-
-  /** Start stdio mode: read JSON-RPC from stdin, write responses to stdout. */
-  async startStdio(): Promise<void> {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-
-    stdin.setEncoding("utf8");
-    let buffer = "";
-
-    stdin.on("data", (chunk: string) => {
-      buffer += chunk;
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        this.processLine(trimmed, stdout);
-      }
-    });
-
-    stdin.on("end", () => {
-      this.logger.info("[mcp-bridge] stdin closed, shutting down");
-      this.shutdown().catch(err => {
-        this.logger.error("[mcp-bridge] Shutdown error:", err);
-      });
-    });
-
-    this.logger.info("[mcp-bridge] Stdio server ready");
-  }
-
-  private processLine(line: string, stdout: NodeJS.WriteStream): void {
-    let request: any;
-    try {
-      request = JSON.parse(line);
-    } catch {
-      this.writeResponse(stdout, {
-        jsonrpc: "2.0",
-        id: 0,
-        error: { code: -32700, message: "Parse error" }
-      });
-      return;
-    }
-
-    // Notifications (no id) — just acknowledge
-    if (request.id === undefined || request.id === null) {
-      // notifications/initialized, etc. — no response needed
-      return;
-    }
-
-    this.handleRequest(request).then(response => {
-      this.writeResponse(stdout, response);
-    }).catch(err => {
-      this.writeResponse(stdout, {
-        jsonrpc: "2.0",
-        id: request.id,
-        error: { code: -32603, message: err instanceof Error ? err.message : String(err) }
-      });
-    });
-  }
-
-  private writeResponse(stdout: NodeJS.WriteStream, response: any): void {
-    stdout.write(JSON.stringify(response) + "\n");
-  }
-
-  /** Handle a single MCP JSON-RPC request. */
-  async handleRequest(request: McpRequest): Promise<McpResponse> {
-    const id = request.id ?? 0;
-
-    switch (request.method) {
-      case "initialize":
-        return this.handleInitialize(id);
-
-      case "tools/list":
-        return this.handleToolsList(id);
-
-      case "tools/call":
-        return this.handleToolsCall(id, request.params);
-
-      case "ping":
-        return { jsonrpc: "2.0", id, result: {} };
-
-      default:
-        return {
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32601, message: `Method not found: ${request.method}` }
-        };
-    }
-  }
-
-  private handleInitialize(id: number): McpResponse {
-    this.initialized = true;
-    return {
-      jsonrpc: "2.0",
-      id,
-      result: {
-        protocolVersion: "2024-11-05",
-        capabilities: {
-          tools: {}
-        },
-        serverInfo: {
-          name: "mcp-bridge",
-          version: PACKAGE_VERSION
-        }
-      }
-    };
-  }
-
-  private async handleToolsList(id: number): Promise<McpResponse> {
-    if (this.isRouterMode()) {
-      return {
-        jsonrpc: "2.0",
-        id,
-        result: {
-          tools: [{
-            name: "mcp",
-            description: McpRouter.generateDescription(this.config.servers),
-            inputSchema: {
-              type: "object",
-              properties: {
-                server: { type: "string", description: "Server name" },
-                action: { type: "string", description: "list | call | refresh | status" },
-                tool: { type: "string", description: "Tool name for action=call" },
-                params: { type: "object", description: "Tool arguments" }
-              },
-              required: ["server"]
-            }
-          }]
-        }
-      };
-    }
-
-    // Direct mode: discover all tools from all servers
-    await this.discoverDirectTools();
-    const tools = this.directTools.map(t => ({
-      name: t.registeredName,
-      description: t.description,
-      inputSchema: t.inputSchema
-    }));
-
-    return { jsonrpc: "2.0", id, result: { tools } };
-  }
-
-  private async handleToolsCall(id: number, params: any): Promise<McpResponse> {
-    const toolName = params?.name;
-    const toolArgs = params?.arguments ?? {};
-
-    if (!toolName) {
-      return {
-        jsonrpc: "2.0",
-        id,
-        error: { code: -32602, message: "Missing tool name" }
-      };
-    }
-
-    if (this.isRouterMode()) {
-      if (toolName !== "mcp") {
-        return {
-          jsonrpc: "2.0",
-          id,
-          error: { code: -32004, message: `Unknown tool: ${toolName}. In router mode, use the 'mcp' tool.` }
-        };
-      }
-
-      const result = await this.router!.dispatch(
-        toolArgs.server,
-        toolArgs.action,
-        toolArgs.tool,
-        toolArgs.params
-      );
-
-      // Check if result is an error
-      if ("error" in result) {
-        return {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            content: [{ type: "text", text: JSON.stringify(result) }]
-          }
-        };
-      }
-
-      return {
-        jsonrpc: "2.0",
-        id,
-        result: {
-          content: [{ type: "text", text: JSON.stringify(result) }]
-        }
-      };
-    }
-
-    // Direct mode: find and call the tool
-    const entry = this.directTools.find(t => t.registeredName === toolName);
-    if (!entry) {
-      return {
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32004,
-          message: `Unknown tool: ${toolName}`,
-          data: { errorType: "unknown_tool" }
-        }
-      };
-    }
-
-    try {
-      const conn = this.directConnections.get(entry.serverName);
-      if (!conn || !conn.transport.isConnected()) {
-        return {
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32001,
-            message: `Server '${entry.serverName}' not connected`,
-            data: { errorType: "connection_failed", server: entry.serverName, retriable: true }
-          }
-        };
-      }
-
-      const response = await conn.transport.sendRequest({
-        jsonrpc: "2.0",
-        method: "tools/call",
-        params: { name: entry.originalName, arguments: toolArgs }
-      });
-
-      if (response.error) {
-        return {
-          jsonrpc: "2.0",
-          id,
-          error: {
-            code: -32005,
-            message: response.error.message,
-            data: { errorType: "mcp_error", server: entry.serverName }
-          }
-        };
-      }
-
-      return { jsonrpc: "2.0", id, result: response.result };
-    } catch (err) {
-      return {
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: -32001,
-          message: err instanceof Error ? err.message : String(err),
-          data: { errorType: "connection_failed", server: entry.serverName, retriable: true }
-        }
-      };
-    }
-  }
-
-  /** Connect to all backend servers and discover their tools (direct mode). */
-  private async discoverDirectTools(): Promise<void> {
-    if (this.directTools.length > 0) return; // Already discovered
-
-    const globalNames = new Set<string>();
-
-    for (const [serverName, serverConfig] of Object.entries(this.config.servers)) {
-      try {
-        const transport = this.createTransport(serverName, serverConfig);
-        await transport.connect();
-        await initializeProtocol(transport, PACKAGE_VERSION);
-
-        this.directConnections.set(serverName, { transport, initialized: true });
-
-        const tools = await fetchToolsList(transport);
-        const localNames = new Set<string>();
-
-        for (const tool of tools) {
-          const registeredName = pickRegisteredToolName(
-            serverName,
-            tool.name,
-            this.config.toolPrefix,
-            localNames,
-            globalNames,
-            this.logger
-          );
-          localNames.add(registeredName);
-          globalNames.add(registeredName);
-
-          this.directTools.push({
-            serverName,
-            originalName: tool.name,
-            registeredName,
-            description: tool.description,
-            inputSchema: tool.inputSchema
-          });
-        }
-
-        this.logger.info(`[mcp-bridge] Discovered ${tools.length} tools from ${serverName}`);
-      } catch (err) {
-        this.logger.error(`[mcp-bridge] Failed to connect to ${serverName}:`, err);
-      }
-    }
-  }
-
-  private createTransport(serverName: string, serverConfig: McpServerConfig): McpTransport {
-    const onReconnected = async () => {
-      this.logger.info(`[mcp-bridge] ${serverName} reconnected`);
-    };
-
-    switch (serverConfig.transport) {
-      case "sse":
-        return new SseTransport(serverConfig, this.config, this.logger, onReconnected);
-      case "stdio":
-        return new StdioTransport(serverConfig, this.config, this.logger, onReconnected);
-      case "streamable-http":
-        return new StreamableHttpTransport(serverConfig, this.config, this.logger, onReconnected);
-      default:
-        throw new Error(`Unsupported transport: ${serverConfig.transport}`);
-    }
-  }
-
-  /** Graceful shutdown: disconnect all backend servers. */
-  async shutdown(): Promise<void> {
-    this.logger.info("[mcp-bridge] Shutting down...");
-
-    if (this.router) {
-      await this.router.disconnectAll();
-    }
-
-    for (const [name, conn] of this.directConnections) {
-      try {
-        await conn.transport.disconnect();
-      } catch (err) {
-        this.logger.error(`[mcp-bridge] Error disconnecting ${name}:`, err);
-      }
-    }
-    this.directConnections.clear();
-
-    this.logger.info("[mcp-bridge] Shutdown complete");
-  }
-}

package/src/tool-naming.ts

@@ -1,51 +0,0 @@
-function isNameTaken(name: string, localNames: Set<string>, globalNames: Set<string>): boolean {
-  return localNames.has(name) || globalNames.has(name);
-}
-
-export function pickRegisteredToolName(
-  serverName: string,
-  toolName: string,
-  toolPrefix: boolean | "auto" | undefined,
-  localNames: Set<string>,
-  globalNames: Set<string>,
-  logger?: { warn: (...args: unknown[]) => void }
-): string {
-  // toolPrefix: true = always prefix, false = never prefix, "auto" = prefix only on collision (default)
-  const effectivePrefix = toolPrefix === undefined ? "auto" : toolPrefix;
-
-  let candidate: string;
-  if (effectivePrefix === true) {
-    // Always prefix with server name
-    candidate = `${serverName}_${toolName}`.replace(/[^a-zA-Z0-9_]/g, "_");
-  } else if (effectivePrefix === false) {
-    // Never prefix — use raw tool name, no collision fallback
-    candidate = toolName.replace(/[^a-zA-Z0-9_]/g, "_");
-  } else {
-    // "auto" — try without prefix, auto-prefix on collision
-    const unprefixed = toolName.replace(/[^a-zA-Z0-9_]/g, "_");
-    if (isNameTaken(unprefixed, localNames, globalNames)) {
-      const prefixedName = `${serverName}_${toolName}`.replace(/[^a-zA-Z0-9_]/g, "_");
-      logger?.warn(
-        `[mcp-bridge] Global tool name collision detected for "${unprefixed}". Auto-prefixing with server name: "${prefixedName}"`
-      );
-      candidate = prefixedName;
-    } else {
-      candidate = unprefixed;
-    }
-  }
-
-  const uniqueBase = candidate;
-  let suffix = 2;
-  while (isNameTaken(candidate, localNames, globalNames)) {
-    candidate = `${uniqueBase}_${suffix}`;
-    suffix += 1;
-  }
-
-  if (candidate !== uniqueBase) {
-    logger?.warn(
-      `[mcp-bridge] Tool name collision after sanitization on server ${serverName}: "${uniqueBase}" -> "${candidate}"`
-    );
-  }
-
-  return candidate;
-}