@aiwerk/mcp-bridge 1.0.0 → 1.0.2

package/src/transport-base.ts

@@ -1,199 +0,0 @@
-import { McpTransport, McpRequest, McpResponse, McpServerConfig } from "./types.js";
-
-export type PendingRequest = { resolve: Function; reject: Function; timeout: NodeJS.Timeout };
-
-/**
- * Base class for all MCP transports. Provides shared logic for:
- * - Message handling (JSON-RPC response routing, notification dispatch)
- * - Pending request management with timeout
- * - Reconnection with exponential backoff + jitter
- * - Environment variable resolution for headers, env, and args
- * - Non-TLS remote URL warnings
- */
-export abstract class BaseTransport implements McpTransport {
-  protected config: McpServerConfig;
-  protected clientConfig: any;
-  protected connected = false;
-  protected pendingRequests = new Map<number, PendingRequest>();
-  protected logger: any;
-  protected reconnectTimer: NodeJS.Timeout | null = null;
-  protected onReconnected?: () => Promise<void>;
-  protected backoffDelay = 0;
-
-  constructor(config: McpServerConfig, clientConfig: any, logger: any, onReconnected?: () => Promise<void>) {
-    this.config = config;
-    this.clientConfig = clientConfig;
-    this.logger = logger;
-    this.onReconnected = onReconnected;
-  }
-
-  abstract connect(): Promise<void>;
-  abstract disconnect(): Promise<void>;
-  abstract sendRequest(request: McpRequest): Promise<McpResponse>;
-  abstract sendNotification(notification: any): Promise<void>;
-
-  isConnected(): boolean {
-    return this.connected;
-  }
-
-  /** Human-readable transport name for log messages (e.g. "stdio", "SSE", "streamable-http"). */
-  protected abstract get transportName(): string;
-
-  /**
-   * Route an incoming JSON-RPC message to the appropriate handler:
-   * - notifications/tools/list_changed -> trigger tool refresh
-   * - Other notifications -> debug log
-   * - Responses with id -> resolve/reject matching pending request
-   */
-  protected handleMessage(message: any): void {
-    if (!message.id && message.method === "notifications/tools/list_changed") {
-      if (this.onReconnected) {
-        this.onReconnected().catch((error) => {
-          this.logger.error("[mcp-bridge] Failed to refresh tools after list_changed notification:", error);
-        });
-      }
-      return;
-    }
-
-    if (!message.id && message.method) {
-      this.logger.debug(`[mcp-bridge] Unhandled ${this.transportName} notification: ${message.method}`);
-      return;
-    }
-
-    if (message.id && this.pendingRequests.has(message.id)) {
-      const pending = this.pendingRequests.get(message.id)!;
-      clearTimeout(pending.timeout);
-      this.pendingRequests.delete(message.id);
-
-      if (message.error) {
-        pending.reject(new Error(message.error.message || "MCP error"));
-      } else {
-        pending.resolve(message);
-      }
-    }
-  }
-
-  /** Reject and clear all pending requests with the given reason. */
-  protected rejectAllPending(reason: string): void {
-    for (const [, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeout);
-      pending.reject(new Error(reason));
-    }
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Schedule a reconnection attempt with exponential backoff and jitter.
-   * Rejects all pending requests before scheduling.
-   */
-  protected scheduleReconnect(): void {
-    if (this.reconnectTimer) return;
-
-    this.connected = false;
-    this.rejectAllPending("Connection lost, request cancelled");
-
-    const baseDelay = this.clientConfig.reconnectIntervalMs || 30000;
-    if (this.backoffDelay <= 0) {
-      this.backoffDelay = baseDelay;
-    }
-    const jitter = 0.5 + Math.random(); // 0.5x-1.5x jitter
-    const reconnectInterval = Math.round(this.backoffDelay * jitter);
-    this.reconnectTimer = setTimeout(async () => {
-      this.reconnectTimer = null;
-      try {
-        await this.connect();
-        this.logger.info(`${this.transportName} transport reconnected successfully`);
-        this.backoffDelay = baseDelay;
-
-        if (this.onReconnected) {
-          await this.onReconnected();
-        }
-      } catch (error) {
-        this.logger.error("Reconnection failed:", error);
-        this.backoffDelay = Math.min(this.backoffDelay * 2, 300000);
-        this.scheduleReconnect();
-      }
-    }, reconnectInterval);
-  }
-
-  /** Cancel any scheduled reconnection timer. */
-  protected cleanupReconnectTimer(): void {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-}
-
-// -- Shared utility functions -----------------------------------------------
-
-/**
- * Resolve ${VAR} placeholders in a single string value using environment variables.
- * Throws if a referenced variable is not defined.
- *
- * @param value - String potentially containing ${VAR} placeholders
- * @param contextDescription - Human-readable context for error messages (e.g. 'header "Authorization"')
- * @param extraEnv - Additional env vars to check before process.env (e.g. merged child process env)
- */
-export function resolveEnvVars(
-  value: string,
-  contextDescription: string,
-  extraEnv?: Record<string, string | undefined>
-): string {
-  return value.replace(/\$\{(\w+)\}/g, (_, varName) => {
-    const resolved = extraEnv?.[varName] ?? process.env[varName];
-    if (resolved === undefined) {
-      throw new Error(`[mcp-bridge] Missing required environment variable "${varName}" while resolving ${contextDescription}`);
-    }
-    return resolved;
-  });
-}
-
-/**
- * Resolve ${VAR} placeholders in all values of a Record<string, string>.
- *
- * @param record - Key-value pairs with potential ${VAR} placeholders in values
- * @param contextPrefix - Prefix for error context (e.g. "header", "env key")
- * @param extraEnv - Additional env vars to check before process.env
- */
-export function resolveEnvRecord(
-  record: Record<string, string>,
-  contextPrefix: string,
-  extraEnv?: Record<string, string | undefined>
-): Record<string, string> {
-  const resolved: Record<string, string> = {};
-  for (const [key, value] of Object.entries(record)) {
-    resolved[key] = resolveEnvVars(value, `${contextPrefix} "${key}"`, extraEnv);
-  }
-  return resolved;
-}
-
-/**
- * Resolve ${VAR} placeholders in an array of command arguments.
- *
- * @param args - Array of argument strings with potential ${VAR} placeholders
- * @param extraEnv - Additional env vars to check before process.env
- */
-export function resolveArgs(
-  args: string[],
-  extraEnv?: Record<string, string | undefined>
-): string[] {
-  return args.map(arg =>
-    resolveEnvVars(arg, `arg "${arg}"`, extraEnv)
-  );
-}
-
-/**
- * Warn if a URL uses non-TLS HTTP to a remote (non-localhost) host.
- */
-export function warnIfNonTlsRemoteUrl(rawUrl: string, logger: any): void {
-  try {
-    const parsed = new URL(rawUrl);
-    if (parsed.protocol !== "http:") return;
-    const host = parsed.hostname;
-    if (host === "localhost" || host === "127.0.0.1" || host === "::1") return;
-    logger.warn(`[mcp-bridge] WARNING: Non-TLS connection to ${host} — credentials may be transmitted in plaintext`);
-  } catch {
-    // Ignore malformed URL here; connect() validation will fail later.
-  }
-}

package/src/transport-sse.ts

@@ -1,230 +0,0 @@
-import { McpRequest, McpResponse, McpServerConfig, nextRequestId } from "./types.js";
-import { BaseTransport, resolveEnvRecord, warnIfNonTlsRemoteUrl } from "./transport-base.js";
-
-export class SseTransport extends BaseTransport {
-  private endpointUrl: string | null = null;
-  private sseAbortController: AbortController | null = null;
-  private currentDataBuffer: string[] = [];
-
-  protected get transportName(): string { return "SSE"; }
-
-  async connect(): Promise<void> {
-    if (!this.config.url) {
-      throw new Error("SSE transport requires URL");
-    }
-
-    warnIfNonTlsRemoteUrl(this.config.url, this.logger);
-    // Validate that all header env vars resolve (fail fast)
-    resolveEnvRecord(this.config.headers || {}, "header");
-
-    this.sseAbortController = new AbortController();
-
-    const connectionTimeout = this.clientConfig.connectionTimeoutMs || 10000;
-    const streamReady = new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("SSE endpoint URL not received within timeout")), connectionTimeout);
-      this._onEndpointReceived = () => { clearTimeout(timer); resolve(); };
-    });
-
-    // Fire and forget the stream reader
-    this.startEventStream().catch((error) => {
-      if (error instanceof Error && error.name !== 'AbortError') {
-        this.logger.error("[mcp-bridge] SSE stream error:", error.message);
-        this.scheduleReconnect();
-      }
-    });
-
-    await streamReady;
-    this.connected = true;
-    this.backoffDelay = this.clientConfig.reconnectIntervalMs || 30000;
-  }
-
-  private _onEndpointReceived: (() => void) | null = null;
-
-  private async startEventStream(): Promise<void> {
-    if (!this.config.url) return;
-
-    const headers = resolveEnvRecord({
-      ...this.config.headers,
-      "Accept": "text/event-stream"
-    }, "header");
-
-    try {
-      const response = await fetch(this.config.url, {
-        method: "GET",
-        headers,
-        signal: this.sseAbortController?.signal
-      });
-
-      if (!response.ok) {
-        throw new Error(`SSE connection failed: HTTP ${response.status}`);
-      }
-
-      if (!response.body) {
-        throw new Error("No response body for SSE stream");
-      }
-
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      let buffer = "";
-      let currentEvent = "";
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || "";
-
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (trimmed.startsWith("event: ")) {
-            currentEvent = trimmed.substring(7).trim();
-          } else if (trimmed === "") {
-            this.processEventLine(line, currentEvent);
-            currentEvent = "";
-          } else {
-            this.processEventLine(line, currentEvent);
-          }
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error && error.name === 'AbortError') return;
-      this.logger.error("SSE stream error:", error);
-      this.scheduleReconnect();
-    }
-  }
-
-  private processEventLine(line: string, currentEvent: string = ""): void {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("event: ")) return;
-
-    if (trimmed.startsWith("data: ")) {
-      this.currentDataBuffer.push(trimmed.substring(6));
-      return;
-    }
-
-    if (trimmed === "") {
-      if (this.currentDataBuffer.length === 0) return;
-
-      const data = this.currentDataBuffer.join("\n");
-      this.currentDataBuffer = [];
-
-      if (currentEvent === "endpoint") {
-        if (data.startsWith("/")) {
-          const base = new URL(this.config.url!);
-          this.endpointUrl = `${base.origin}${data}`;
-        } else if (data.startsWith("http")) {
-          if (!this.isSameOrigin(data)) {
-            this.logger.warn(`[mcp-bridge] Rejected SSE endpoint with mismatched origin: ${data}`);
-            return;
-          }
-          this.endpointUrl = data;
-        } else {
-          this.logger.warn(`[mcp-bridge] Rejected SSE endpoint with unsupported URL format: ${data}`);
-          return;
-        }
-        this.logger.info(`[mcp-bridge] SSE endpoint URL received: ${this.endpointUrl}`);
-        if (this._onEndpointReceived) {
-          this._onEndpointReceived();
-          this._onEndpointReceived = null;
-        }
-        return;
-      }
-
-      try {
-        const message = JSON.parse(data);
-        this.handleMessage(message);
-      } catch {
-        this.logger.debug("Failed to parse SSE data as JSON:", data);
-      }
-    }
-  }
-
-  async sendNotification(notification: any): Promise<void> {
-    if (!this.connected || !this.endpointUrl) {
-      throw new Error("SSE transport not connected or no endpoint URL");
-    }
-    const headers = resolveEnvRecord({
-      ...this.config.headers,
-      "Content-Type": "application/json"
-    }, "header");
-    const response = await fetch(this.endpointUrl!, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(notification)
-    });
-    if (!response.ok) {
-      this.logger.warn(`[mcp-bridge] SSE notification got HTTP ${response.status}`);
-    }
-  }
-
-  async sendRequest(request: McpRequest): Promise<McpResponse> {
-    if (!this.connected || !this.endpointUrl) {
-      throw new Error("SSE transport not connected or no endpoint URL");
-    }
-
-    const id = nextRequestId();
-    const requestWithId = { ...request, id };
-
-    return new Promise((resolve, reject) => {
-      const requestTimeout = this.clientConfig.requestTimeoutMs || 60000;
-      const timeout = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error(`Request timeout after ${requestTimeout}ms`));
-      }, requestTimeout);
-
-      this.pendingRequests.set(id, { resolve, reject, timeout });
-
-      const headers = resolveEnvRecord({
-        ...this.config.headers,
-        "Content-Type": "application/json"
-      }, "header");
-
-      // The response arrives via the SSE stream (handleMessage), not from this fetch.
-      // The fetch only confirms the server accepted the request (HTTP 200).
-      // If the fetch fails, we reject immediately; otherwise we wait for the SSE stream.
-      fetch(this.endpointUrl!, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(requestWithId)
-      })
-        .then((response) => {
-          if (!response.ok) {
-            clearTimeout(timeout);
-            this.pendingRequests.delete(id);
-            reject(new Error(`HTTP ${response.status}`));
-          }
-        })
-        .catch((error) => {
-          clearTimeout(timeout);
-          this.pendingRequests.delete(id);
-          reject(error);
-        });
-    });
-  }
-
-  private isSameOrigin(url: string): boolean {
-    try {
-      if (!this.config.url) return false;
-      const incoming = new URL(url);
-      const base = new URL(this.config.url);
-      return incoming.origin === base.origin;
-    } catch {
-      return false;
-    }
-  }
-
-  async disconnect(): Promise<void> {
-    this.connected = false;
-    this.cleanupReconnectTimer();
-
-    if (this.sseAbortController) {
-      this.sseAbortController.abort();
-      this.sseAbortController = null;
-    }
-
-    this.rejectAllPending("Connection closed");
-  }
-}