@aiwerk/mcp-bridge 1.0.0 → 1.0.2

package/src/config.ts

@@ -1,168 +0,0 @@
-import { readFileSync, existsSync, mkdirSync, writeFileSync, chmodSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { BridgeConfig, Logger } from "./types.js";
-import { resolveEnvVars } from "./transport-base.js";
-import { randomBytes } from "crypto";
-
-const DEFAULT_CONFIG_DIR = join(homedir(), ".mcp-bridge");
-const DEFAULT_CONFIG_FILE = "config.json";
-const DEFAULT_ENV_FILE = ".env";
-
-/** Parse a simple KEY=VALUE .env file (no npm dependency). */
-export function parseEnvFile(content: string): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIdx = trimmed.indexOf("=");
-    if (eqIdx === -1) continue;
-    const key = trimmed.substring(0, eqIdx).trim();
-    let value = trimmed.substring(eqIdx + 1).trim();
-    // Strip surrounding quotes
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    if (key) env[key] = value;
-  }
-  return env;
-}
-
-/** Recursively resolve ${VAR} placeholders in a JSON-compatible value. */
-function resolveConfigValue(value: unknown, extraEnv: Record<string, string | undefined>): unknown {
-  if (typeof value === "string") {
-    return resolveEnvVars(value, "config value", extraEnv);
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => resolveConfigValue(item, extraEnv));
-  }
-  if (value !== null && typeof value === "object") {
-    const resolved: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(value)) {
-      resolved[k] = resolveConfigValue(v, extraEnv);
-    }
-    return resolved;
-  }
-  return value;
-}
-
-export interface LoadConfigOptions {
-  configPath?: string;
-  logger?: Logger;
-}
-
-/**
- * Load and validate bridge config.
- * 1. Read ~/.mcp-bridge/config.json (or custom path)
- * 2. Parse ~/.mcp-bridge/.env
- * 3. Resolve ${ENV_VAR} in config values
- * 4. Validate required fields
- */
-export function loadConfig(options: LoadConfigOptions = {}): BridgeConfig {
-  const configDir = options.configPath
-    ? join(options.configPath, "..")  // If a file path is given, derive directory
-    : DEFAULT_CONFIG_DIR;
-
-  const configPath = options.configPath || join(DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_FILE);
-  const envPath = join(
-    options.configPath ? join(options.configPath, "..") : DEFAULT_CONFIG_DIR,
-    DEFAULT_ENV_FILE
-  );
-
-  if (!existsSync(configPath)) {
-    throw new Error(
-      `Config file not found: ${configPath}\nRun 'mcp-bridge init' to set up.`
-    );
-  }
-
-  // Load .env file
-  let dotEnv: Record<string, string> = {};
-  if (existsSync(envPath)) {
-    try {
-      dotEnv = parseEnvFile(readFileSync(envPath, "utf-8"));
-    } catch (err) {
-      options.logger?.warn(`[mcp-bridge] Failed to parse .env file: ${err instanceof Error ? err.message : err}`);
-    }
-  }
-
-  // Merge .env into process.env (don't overwrite existing)
-  for (const [key, value] of Object.entries(dotEnv)) {
-    if (process.env[key] === undefined) {
-      process.env[key] = value;
-    }
-  }
-
-  // Read and parse config
-  const rawConfig = JSON.parse(readFileSync(configPath, "utf-8"));
-
-  // Resolve ${VAR} placeholders using .env + process.env
-  const mergedEnv: Record<string, string | undefined> = { ...dotEnv };
-  for (const [k, v] of Object.entries(process.env)) {
-    if (mergedEnv[k] === undefined) mergedEnv[k] = v;
-  }
-
-  let config: BridgeConfig;
-  try {
-    config = resolveConfigValue(rawConfig, mergedEnv) as BridgeConfig;
-  } catch (err) {
-    throw new Error(`Config resolution failed: ${err instanceof Error ? err.message : err}`);
-  }
-
-  // Validate required fields
-  if (!config.servers || typeof config.servers !== "object") {
-    throw new Error("Config must have a 'servers' object");
-  }
-
-  return config;
-}
-
-/** Get the default config directory path. */
-export function getConfigDir(configPath?: string): string {
-  return configPath ? join(configPath, "..") : DEFAULT_CONFIG_DIR;
-}
-
-/** Initialize the config directory with template files. */
-export function initConfigDir(logger: Logger): void {
-  const dir = DEFAULT_CONFIG_DIR;
-
-  mkdirSync(dir, { recursive: true });
-
-  // Set directory permissions (Linux/macOS)
-  try {
-    chmodSync(dir, 0o700);
-  } catch { /* Windows doesn't support chmod */ }
-
-  const configPath = join(dir, DEFAULT_CONFIG_FILE);
-  if (!existsSync(configPath)) {
-    const template: BridgeConfig = {
-      mode: "router",
-      servers: {},
-      toolPrefix: true,
-      connectionTimeoutMs: 5000,
-      requestTimeoutMs: 60000,
-      routerIdleTimeoutMs: 600000,
-      routerMaxConcurrent: 5,
-      http: {
-        auth: {
-          type: "bearer",
-          token: "${MCP_BRIDGE_TOKEN}"
-        }
-      }
-    };
-    writeFileSync(configPath, JSON.stringify(template, null, 2) + "\n");
-    logger.info(`Created config: ${configPath}`);
-  }
-
-  const envPath = join(dir, DEFAULT_ENV_FILE);
-  if (!existsSync(envPath)) {
-    const token = randomBytes(32).toString("hex");
-    writeFileSync(envPath, `# MCP Bridge environment variables\nMCP_BRIDGE_TOKEN=${token}\n`);
-    try {
-      chmodSync(envPath, 0o600);
-    } catch { /* Windows */ }
-    logger.info(`Created .env: ${envPath} (with generated token)`);
-  }
-
-  logger.info(`Config directory ready: ${dir}`);
-}

package/src/mcp-router.ts

@@ -1,366 +0,0 @@
-import {
-  McpClientConfig,
-  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";
-import { fetchToolsList, initializeProtocol, PACKAGE_VERSION } from "./protocol.js";
-
-type RouterErrorCode =
-  | "unknown_server"
-  | "unknown_tool"
-  | "connection_failed"
-  | "mcp_error"
-  | "invalid_params";
-
-export interface RouterToolHint {
-  name: string;
-  description: string;
-  requiredParams: string[];
-}
-
-export interface RouterServerStatus {
-  name: string;
-  transport: string;
-  status: "connected" | "idle" | "disconnected";
-  tools: number;
-  lastUsed?: string;
-}
-
-export type RouterDispatchResponse =
-  | { server: string; action: "list"; tools: RouterToolHint[] }
-  | { server: string; action: "refresh"; refreshed: true; tools: RouterToolHint[] }
-  | { server: string; action: "call"; tool: string; result: any }
-  | { action: "status"; servers: RouterServerStatus[] }
-  | {
-      error: RouterErrorCode;
-      message: string;
-      available?: string[];
-      code?: number;
-    };
-
-export interface RouterTransportRefs {
-  sse: new (config: McpServerConfig, clientConfig: McpClientConfig, logger: any, onReconnected?: () => Promise<void>) => McpTransport;
-  stdio: new (config: McpServerConfig, clientConfig: McpClientConfig, logger: any, onReconnected?: () => Promise<void>) => McpTransport;
-  streamableHttp: new (config: McpServerConfig, clientConfig: McpClientConfig, logger: any, onReconnected?: () => Promise<void>) => McpTransport;
-}
-
-interface RouterServerState {
-  transport: McpTransport;
-  initialized: boolean;
-  toolsCache?: RouterToolHint[];
-  toolNames: string[];
-  lastUsedAt: number;
-  idleTimer: NodeJS.Timeout | null;
-  initPromise?: Promise<void>;
-}
-
-const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
-const DEFAULT_MAX_CONCURRENT = 5;
-
-export class McpRouter {
-  private readonly servers: Record<string, McpServerConfig>;
-  private readonly clientConfig: McpClientConfig;
-  private readonly logger: any;
-  private readonly transportRefs: RouterTransportRefs;
-  private readonly idleTimeoutMs: number;
-  private readonly maxConcurrent: number;
-  private readonly states = new Map<string, RouterServerState>();
-
-  constructor(
-    servers: Record<string, McpServerConfig>,
-    clientConfig: McpClientConfig,
-    logger: any,
-    transportRefs?: Partial<RouterTransportRefs>
-  ) {
-    this.servers = servers;
-    this.clientConfig = clientConfig;
-    this.logger = logger;
-    this.transportRefs = {
-      sse: transportRefs?.sse ?? SseTransport,
-      stdio: transportRefs?.stdio ?? StdioTransport,
-      streamableHttp: transportRefs?.streamableHttp ?? StreamableHttpTransport
-    };
-    this.idleTimeoutMs = clientConfig.routerIdleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
-    this.maxConcurrent = clientConfig.routerMaxConcurrent ?? DEFAULT_MAX_CONCURRENT;
-  }
-
-  static generateDescription(servers: Record<string, McpServerConfig>): string {
-    const serverNames = Object.keys(servers);
-    if (serverNames.length === 0) {
-      return "Call MCP server tools. No servers configured.";
-    }
-
-    const serverList = serverNames
-      .map((name) => {
-        const desc = servers[name].description;
-        return desc ? `${name} (${desc})` : name;
-      })
-      .join(", ");
-
-    return `Call any MCP server tool. Servers: ${serverList}. Use action='list' to discover tools and required parameters, action='call' to execute a tool, action='refresh' to clear cache and re-discover tools, and action='status' to check server connection states. If the user mentions a specific tool by name, the call action auto-connects and works without listing first.`;
-  }
-
-  async dispatch(server?: string, action: string = "call", tool?: string, params?: any): Promise<RouterDispatchResponse> {
-    try {
-      const normalizedAction = action || "call";
-
-      // Status action: no server required, shows all server states
-      if (normalizedAction === "status") {
-        return this.getStatus();
-      }
-
-      if (!server) {
-        return this.error("invalid_params", "server is required");
-      }
-      if (!this.servers[server]) {
-        return this.error("unknown_server", `Server '${server}' not found`, Object.keys(this.servers));
-      }
-      if (normalizedAction === "list") {
-        try {
-          const tools = await this.getToolList(server);
-          return { server, action: "list", tools };
-        } catch (error) {
-          return this.error("connection_failed", `Failed to connect to ${server}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-
-      if (normalizedAction === "refresh") {
-        try {
-          const state = await this.ensureConnected(server);
-          state.toolsCache = undefined;
-          state.toolNames = [];
-          const tools = await this.getToolList(server);
-          return { server, action: "refresh", refreshed: true, tools };
-        } catch (error) {
-          return this.error("connection_failed", `Failed to connect to ${server}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-
-      if (normalizedAction !== "call") {
-        return this.error("invalid_params", `action must be one of: list, call, refresh`);
-      }
-
-      if (!tool) {
-        return this.error("invalid_params", "tool is required for action=call");
-      }
-
-      try {
-        await this.getToolList(server);
-      } catch (error) {
-        return this.error("connection_failed", `Failed to connect to ${server}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-      const state = this.states.get(server)!;
-
-      if (!state.toolNames.includes(tool)) {
-        return this.error("unknown_tool", `Tool '${tool}' not found on server '${server}'`, state.toolNames);
-      }
-
-      this.markUsed(server);
-      const response = await state.transport.sendRequest({
-        jsonrpc: "2.0",
-        method: "tools/call",
-        params: {
-          name: tool,
-          arguments: params ?? {}
-        }
-      });
-
-      if (response.error) {
-        return this.error("mcp_error", response.error.message, undefined, response.error.code);
-      }
-
-      return { server, action: "call", tool, result: response.result };
-    } catch (error) {
-      return this.error("mcp_error", error instanceof Error ? error.message : String(error));
-    }
-  }
-
-  async getToolList(server: string): Promise<RouterToolHint[]> {
-    if (!this.servers[server]) {
-      throw new Error(`Server '${server}' not found`);
-    }
-
-    const state = await this.ensureConnected(server);
-    if (state.toolsCache) {
-      this.markUsed(server);
-      return state.toolsCache;
-    }
-
-    const tools = await fetchToolsList(state.transport);
-    state.toolNames = tools.map((tool) => tool.name);
-    state.toolsCache = tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description || "",
-      requiredParams: this.extractRequiredParams(tool)
-    }));
-
-    this.markUsed(server);
-    return state.toolsCache;
-  }
-
-  private getStatus(): RouterDispatchResponse {
-    const serverStatuses: RouterServerStatus[] = Object.entries(this.servers).map(([name, config]) => {
-      const state = this.states.get(name);
-      let status: "connected" | "idle" | "disconnected" = "disconnected";
-      if (state?.transport.isConnected()) {
-        const idleMs = Date.now() - state.lastUsedAt;
-        status = idleMs > 60_000 ? "idle" : "connected";
-      }
-      return {
-        name,
-        transport: config.transport,
-        status,
-        tools: state?.toolNames.length ?? 0,
-        ...(state?.lastUsedAt ? { lastUsed: new Date(state.lastUsedAt).toISOString() } : {})
-      };
-    });
-    return { action: "status", servers: serverStatuses };
-  }
-
-  async disconnectAll(): Promise<void> {
-    for (const serverName of Object.keys(this.servers)) {
-      await this.disconnectServer(serverName);
-    }
-  }
-
-  private async ensureConnected(server: string): Promise<RouterServerState> {
-    let state = this.states.get(server);
-    if (!state) {
-      const transport = this.createTransport(server, this.servers[server]);
-      state = {
-        transport,
-        initialized: false,
-        toolNames: [],
-        lastUsedAt: Date.now(),
-        idleTimer: null
-      };
-      this.states.set(server, state);
-    }
-
-    if (state.initPromise) {
-      await state.initPromise;
-      return state;
-    }
-
-    state.initPromise = (async () => {
-      if (!state!.transport.isConnected()) {
-        await state!.transport.connect();
-      }
-      if (!state!.initialized) {
-        await initializeProtocol(state!.transport, PACKAGE_VERSION);
-        state!.initialized = true;
-      }
-      this.markUsed(server);
-      await this.enforceMaxConcurrent(server);
-    })();
-
-    try {
-      await state.initPromise;
-      return state;
-    } finally {
-      state.initPromise = undefined;
-    }
-  }
-
-  private async enforceMaxConcurrent(activeServer: string): Promise<void> {
-    const connectedServers = [...this.states.entries()]
-      .filter(([_, s]) => s.transport.isConnected())
-      .map(([name, s]) => ({ name, lastUsedAt: s.lastUsedAt }));
-
-    if (connectedServers.length <= this.maxConcurrent) {
-      return;
-    }
-
-    connectedServers.sort((a, b) => a.lastUsedAt - b.lastUsedAt);
-    for (const candidate of connectedServers) {
-      if (candidate.name === activeServer) {
-        continue;
-      }
-      await this.disconnectServer(candidate.name);
-      this.logger.info(`[mcp-bridge] Router evicted idle server via LRU: ${candidate.name}`);
-      return;
-    }
-  }
-
-  private async disconnectServer(server: string): Promise<void> {
-    const state = this.states.get(server);
-    if (!state) return;
-
-    if (state.idleTimer) {
-      clearTimeout(state.idleTimer);
-      state.idleTimer = null;
-    }
-
-    if (state.transport.isConnected()) {
-      await state.transport.disconnect();
-    }
-
-    state.initialized = false;
-    state.toolsCache = undefined;
-    state.toolNames = [];
-  }
-
-  private markUsed(server: string): void {
-    const state = this.states.get(server);
-    if (!state) return;
-
-    state.lastUsedAt = Date.now();
-
-    if (state.idleTimer) {
-      clearTimeout(state.idleTimer);
-    }
-
-    state.idleTimer = setTimeout(() => {
-      this.disconnectServer(server).catch((error) => {
-        this.logger.warn(`[mcp-bridge] Router idle disconnect failed for ${server}:`, error);
-      });
-    }, this.idleTimeoutMs);
-    // Don't keep the process alive just for idle disconnect
-    if (state.idleTimer && typeof state.idleTimer.unref === "function") {
-      state.idleTimer.unref();
-    }
-  }
-
-  private createTransport(serverName: string, serverConfig: McpServerConfig): McpTransport {
-    const onReconnected = async () => {
-      const state = this.states.get(serverName);
-      if (!state) return;
-      state.initialized = false;
-      state.toolsCache = undefined;
-      state.toolNames = [];
-    };
-
-    if (serverConfig.transport === "sse") {
-      return new this.transportRefs.sse(serverConfig, this.clientConfig, this.logger, onReconnected);
-    }
-    if (serverConfig.transport === "stdio") {
-      return new this.transportRefs.stdio(serverConfig, this.clientConfig, this.logger, onReconnected);
-    }
-    if (serverConfig.transport === "streamable-http") {
-      return new this.transportRefs.streamableHttp(serverConfig, this.clientConfig, this.logger, onReconnected);
-    }
-
-    throw new Error(`Unsupported transport: ${serverConfig.transport}`);
-  }
-
-  private extractRequiredParams(tool: McpTool): string[] {
-    const required = tool.inputSchema?.required;
-    if (!Array.isArray(required)) {
-      return [];
-    }
-    return required.filter((name: unknown) => typeof name === "string");
-  }
-
-  private error(error: RouterErrorCode, message: string, available?: string[], code?: number): RouterDispatchResponse {
-    return {
-      error,
-      message,
-      ...(available ? { available } : {}),
-      ...(typeof code === "number" ? { code } : {})
-    };
-  }
-}

package/src/protocol.ts

@@ -1,69 +0,0 @@
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { McpRequest, McpResponse, McpTool, McpTransport } from "./types.js";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export const PACKAGE_VERSION: string = (() => {
-  try {
-    return JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8")).version;
-  } catch {
-    return "0.0.0";
-  }
-})();
-
-export async function initializeProtocol(transport: McpTransport, version: string): Promise<void> {
-  const initRequest: McpRequest = {
-    jsonrpc: "2.0",
-    method: "initialize",
-    params: {
-      protocolVersion: "2024-11-05",
-      capabilities: {},
-      clientInfo: {
-        name: "mcp-bridge",
-        version: version || PACKAGE_VERSION
-      }
-    }
-  };
-
-  const response = await transport.sendRequest(initRequest);
-  if (response.error) {
-    throw new Error(`Initialize failed: ${response.error.message}`);
-  }
-
-  await transport.sendNotification({
-    jsonrpc: "2.0",
-    method: "notifications/initialized"
-  });
-}
-
-export async function fetchToolsList(transport: McpTransport): Promise<McpTool[]> {
-  const allTools: McpTool[] = [];
-  let cursor: string | undefined;
-
-  while (true) {
-    const request: McpRequest = {
-      jsonrpc: "2.0",
-      method: "tools/list",
-      ...(cursor ? { params: { cursor } } : {})
-    };
-
-    const response: McpResponse = await transport.sendRequest(request);
-    if (response.error) {
-      throw new Error(response.error.message);
-    }
-
-    const pageTools = Array.isArray(response.result?.tools) ? response.result.tools : [];
-    allTools.push(...pageTools);
-
-    const nextCursor = response.result?.nextCursor;
-    if (!nextCursor) {
-      break;
-    }
-    cursor = nextCursor;
-  }
-
-  return allTools;
-}