@aiwerk/mcp-bridge 1.0.0 → 1.0.1

package/dist/bin/mcp-bridge.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/mcp-bridge.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import { loadConfig, initConfigDir } from "../src/config.js";
+import { StandaloneServer } from "../src/standalone-server.js";
+import { PACKAGE_VERSION } from "../src/protocol.js";
+import { checkForUpdate, runUpdate } from "../src/update-checker.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// After tsc, this file lives at dist/bin/mcp-bridge.js.
+// Package root is two levels up: dist/bin/ -> dist/ -> package root.
+const PACKAGE_ROOT = join(__dirname, "..", "..");
+function createLogger(level) {
+    const levels = { error: 0, warn: 1, info: 2, debug: 3 };
+    const threshold = levels[level];
+    const ts = () => new Date().toISOString().replace("T", " ").replace("Z", "");
+    return {
+        error: (...args) => {
+            if (threshold >= 0)
+                process.stderr.write(`[${ts()}] [ERROR] ${args.map(String).join(" ")}\n`);
+        },
+        warn: (...args) => {
+            if (threshold >= 1)
+                process.stderr.write(`[${ts()}] [WARN] ${args.map(String).join(" ")}\n`);
+        },
+        info: (...args) => {
+            if (threshold >= 2)
+                process.stderr.write(`[${ts()}] [INFO] ${args.map(String).join(" ")}\n`);
+        },
+        debug: (...args) => {
+            if (threshold >= 3)
+                process.stderr.write(`[${ts()}] [DEBUG] ${args.map(String).join(" ")}\n`);
+        },
+    };
+}
+function parseArgs(argv) {
+    const args = {
+        command: "serve",
+        sse: false,
+        http: false,
+        port: 3000,
+        verbose: false,
+        debug: false,
+        positional: [],
+        checkOnly: false,
+        offline: false,
+    };
+    let i = 0;
+    while (i < argv.length) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--sse":
+                args.sse = true;
+                break;
+            case "--http":
+                args.http = true;
+                break;
+            case "--port":
+                i++;
+                args.port = parseInt(argv[i], 10);
+                if (isNaN(args.port)) {
+                    process.stderr.write("Error: --port requires a number\n");
+                    process.exit(1);
+                }
+                break;
+            case "--config":
+                i++;
+                args.configPath = resolve(argv[i]);
+                break;
+            case "--verbose":
+                args.verbose = true;
+                break;
+            case "--debug":
+                args.debug = true;
+                break;
+            case "--version":
+                args.command = "version";
+                break;
+            case "--help":
+            case "-h":
+                args.command = "help";
+                break;
+            case "--check":
+                args.checkOnly = true;
+                break;
+            case "--offline":
+                args.offline = true;
+                break;
+            case "init":
+                args.command = "init";
+                break;
+            case "install":
+                args.command = "install";
+                break;
+            case "catalog":
+                args.command = "catalog";
+                break;
+            case "servers":
+                args.command = "servers";
+                break;
+            case "search":
+                args.command = "search";
+                break;
+            case "update":
+                args.command = "update";
+                break;
+            default:
+                if (!arg.startsWith("-")) {
+                    args.positional.push(arg);
+                }
+                break;
+        }
+        i++;
+    }
+    return args;
+}
+// -- Commands -------------------------------------------------------------
+function printVersion() {
+    process.stdout.write(`mcp-bridge ${PACKAGE_VERSION}\n`);
+}
+function printHelp() {
+    process.stdout.write(`
+mcp-bridge v${PACKAGE_VERSION} — MCP server multiplexer
+
+Usage:
+  mcp-bridge                        Start in stdio mode (default)
+  mcp-bridge --sse --port 3000      Start as SSE server
+  mcp-bridge --http --port 3000     Start as streamable-http server
+  mcp-bridge init                   Create ~/.mcp-bridge/ with config template
+  mcp-bridge install <server>       Install a server from the catalog
+  mcp-bridge catalog [--offline]    List available servers
+  mcp-bridge servers                List configured servers
+  mcp-bridge search <query>         Search catalog by keyword
+  mcp-bridge update [--check]       Check for / install updates
+
+Options:
+  --config PATH     Custom config file (default: ~/.mcp-bridge/config.json)
+  --verbose         Info-level logs to stderr
+  --debug           Full protocol-level logs to stderr
+  --version         Print version
+  --help            Show this help
+
+All logs go to stderr. Stdout is reserved for the MCP protocol (stdio mode).
+`);
+}
+function cmdInit(logger) {
+    initConfigDir(logger);
+}
+function cmdCatalog(logger, offline) {
+    const catalogPath = join(PACKAGE_ROOT, "servers", "index.json");
+    if (!existsSync(catalogPath)) {
+        logger.error("Server catalog not found");
+        process.exit(1);
+    }
+    const catalog = JSON.parse(readFileSync(catalogPath, "utf-8"));
+    const servers = catalog.servers || {};
+    process.stdout.write("\nAvailable servers:\n\n");
+    process.stdout.write("  Server          Transport    Description\n");
+    process.stdout.write("  " + "─".repeat(60) + "\n");
+    for (const [name, info] of Object.entries(servers)) {
+        const padded = name.padEnd(16);
+        const transport = (info.transport || "stdio").padEnd(13);
+        process.stdout.write(`  ${padded}${transport}${info.description || ""}\n`);
+    }
+    process.stdout.write("\n");
+}
+function cmdServers(logger, configPath) {
+    try {
+        const config = loadConfig({ configPath, logger });
+        const servers = config.servers || {};
+        const entries = Object.entries(servers);
+        if (entries.length === 0) {
+            process.stdout.write("No servers configured.\n");
+            return;
+        }
+        process.stdout.write("\nConfigured servers:\n\n");
+        process.stdout.write("  Server          Transport    Description\n");
+        process.stdout.write("  " + "─".repeat(60) + "\n");
+        for (const [name, serverConfig] of entries) {
+            const padded = name.padEnd(16);
+            const transport = serverConfig.transport.padEnd(13);
+            process.stdout.write(`  ${padded}${transport}${serverConfig.description || ""}\n`);
+        }
+        process.stdout.write("\n");
+    }
+    catch (err) {
+        logger.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+function cmdSearch(query, logger) {
+    const catalogPath = join(PACKAGE_ROOT, "servers", "index.json");
+    if (!existsSync(catalogPath)) {
+        logger.error("Server catalog not found");
+        process.exit(1);
+    }
+    const catalog = JSON.parse(readFileSync(catalogPath, "utf-8"));
+    const servers = catalog.servers || {};
+    const lowerQuery = query.toLowerCase();
+    const matches = Object.entries(servers).filter(([name, info]) => {
+        return name.toLowerCase().includes(lowerQuery) ||
+            (info.description || "").toLowerCase().includes(lowerQuery);
+    });
+    if (matches.length === 0) {
+        process.stdout.write(`No servers matching "${query}"\n`);
+        return;
+    }
+    process.stdout.write(`\nSearch results for "${query}":\n\n`);
+    for (const [i, [name, info]] of matches.entries()) {
+        process.stdout.write(`  ${i + 1}  ${name.padEnd(16)}${info.description || ""}\n`);
+    }
+    process.stdout.write("\n");
+}
+function cmdInstall(serverName, logger) {
+    const scriptPath = join(PACKAGE_ROOT, "scripts", "install-server.sh");
+    if (!existsSync(scriptPath)) {
+        logger.error("Install script not found");
+        process.exit(1);
+    }
+    try {
+        execSync(`bash "${scriptPath}" "${serverName}"`, { stdio: "inherit" });
+    }
+    catch (err) {
+        process.exit(1);
+    }
+}
+async function cmdUpdate(logger, checkOnly) {
+    if (checkOnly) {
+        const info = await checkForUpdate(logger);
+        if (info.updateAvailable) {
+            process.stdout.write(`Update available: ${info.currentVersion} → ${info.latestVersion}\n`);
+            process.stdout.write(`Run 'mcp-bridge update' to install.\n`);
+        }
+        else {
+            process.stdout.write(`mcp-bridge ${info.currentVersion} is up to date.\n`);
+        }
+        return;
+    }
+    const result = await runUpdate(logger);
+    process.stdout.write(result + "\n");
+}
+async function cmdServe(args, logger) {
+    let config;
+    try {
+        config = loadConfig({ configPath: args.configPath, logger });
+    }
+    catch (err) {
+        logger.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    // HTTP modes: require auth
+    if ((args.sse || args.http) && !config.http?.auth?.token) {
+        logger.error("HTTP auth not configured. Set http.auth in config or use stdio mode.");
+        process.exit(1);
+    }
+    const server = new StandaloneServer(config, logger);
+    // Graceful shutdown
+    const shutdown = async () => {
+        await server.shutdown();
+        process.exit(0);
+    };
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    if (args.sse || args.http) {
+        // SSE/HTTP mode: not yet implemented in standalone, show message
+        logger.error("SSE and HTTP server modes are not yet implemented. Use stdio mode (default).");
+        process.exit(1);
+    }
+    // Default: stdio mode
+    await server.startStdio();
+}
+// -- Main -----------------------------------------------------------------
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const logLevel = args.debug ? "debug" : args.verbose ? "info" : "warn";
+    const logger = createLogger(logLevel);
+    switch (args.command) {
+        case "version":
+            printVersion();
+            break;
+        case "help":
+            printHelp();
+            break;
+        case "init":
+            cmdInit(logger);
+            break;
+        case "catalog":
+            cmdCatalog(logger, args.offline);
+            break;
+        case "servers":
+            cmdServers(logger, args.configPath);
+            break;
+        case "search":
+            if (args.positional.length === 0) {
+                process.stderr.write("Usage: mcp-bridge search <query>\n");
+                process.exit(1);
+            }
+            cmdSearch(args.positional[0], logger);
+            break;
+        case "install":
+            if (args.positional.length === 0) {
+                process.stderr.write("Usage: mcp-bridge install <server>\n");
+                process.exit(1);
+            }
+            cmdInstall(args.positional[0], logger);
+            break;
+        case "update":
+            await cmdUpdate(logger, args.checkOnly);
+            break;
+        case "serve":
+            await cmdServe(args, logger);
+            break;
+    }
+}
+main().catch(err => {
+    process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/src/config.d.ts

@@ -0,0 +1,19 @@
+import { BridgeConfig, Logger } from "./types.js";
+/** Parse a simple KEY=VALUE .env file (no npm dependency). */
+export declare function parseEnvFile(content: string): Record<string, string>;
+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 declare function loadConfig(options?: LoadConfigOptions): BridgeConfig;
+/** Get the default config directory path. */
+export declare function getConfigDir(configPath?: string): string;
+/** Initialize the config directory with template files. */
+export declare function initConfigDir(logger: Logger): void;

package/dist/src/config.js

@@ -0,0 +1,145 @@
+import { readFileSync, existsSync, mkdirSync, writeFileSync, chmodSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+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) {
+    const env = {};
+    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, extraEnv) {
+    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 = {};
+        for (const [k, v] of Object.entries(value)) {
+            resolved[k] = resolveConfigValue(v, extraEnv);
+        }
+        return resolved;
+    }
+    return value;
+}
+/**
+ * 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 = {}) {
+    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 = {};
+    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 = { ...dotEnv };
+    for (const [k, v] of Object.entries(process.env)) {
+        if (mergedEnv[k] === undefined)
+            mergedEnv[k] = v;
+    }
+    let config;
+    try {
+        config = resolveConfigValue(rawConfig, mergedEnv);
+    }
+    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) {
+    return configPath ? join(configPath, "..") : DEFAULT_CONFIG_DIR;
+}
+/** Initialize the config directory with template files. */
+export function initConfigDir(logger) {
+    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 = {
+            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/index.ts → dist/src/index.d.ts}

@@ -1,44 +1,15 @@
-// Core exports for @aiwerk/mcp-bridge
-
-// Transport classes
 export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, warnIfNonTlsRemoteUrl } from "./transport-base.js";
 export { StdioTransport } from "./transport-stdio.js";
 export { SseTransport } from "./transport-sse.js";
 export { StreamableHttpTransport } from "./transport-streamable-http.js";
-
-// Router
 export { McpRouter } from "./mcp-router.js";
 export type { RouterToolHint, RouterServerStatus, RouterDispatchResponse, RouterTransportRefs } from "./mcp-router.js";
-
-// Schema conversion
 export { convertJsonSchemaToTypeBox, createToolParameters, setTypeBoxLoader, setSchemaLogger } from "./schema-convert.js";
-
-// Protocol helpers
 export { initializeProtocol, fetchToolsList, PACKAGE_VERSION } from "./protocol.js";
-
-// Config
 export { loadConfig, parseEnvFile, initConfigDir, getConfigDir } from "./config.js";
-
-// Types
-export type {
-  Logger,
-  McpServerConfig,
-  McpClientConfig,
-  McpTool,
-  McpRequest,
-  McpResponse,
-  McpTransport,
-  McpServerConnection,
-  BridgeConfig,
-} from "./types.js";
+export type { Logger, McpServerConfig, McpClientConfig, McpTool, McpRequest, McpResponse, McpTransport, McpServerConnection, BridgeConfig, } from "./types.js";
 export { nextRequestId } from "./types.js";
-
-// Tool naming
 export { pickRegisteredToolName } from "./tool-naming.js";
-
-// Standalone server
 export { StandaloneServer } from "./standalone-server.js";
-
-// Update checker
 export { checkForUpdate, getUpdateNotice, runUpdate, resetNoticeFlag } from "./update-checker.js";
 export type { UpdateInfo } from "./update-checker.js";

package/dist/src/index.js

@@ -0,0 +1,21 @@
+// Core exports for @aiwerk/mcp-bridge
+// Transport classes
+export { BaseTransport, resolveEnvVars, resolveEnvRecord, resolveArgs, warnIfNonTlsRemoteUrl } from "./transport-base.js";
+export { StdioTransport } from "./transport-stdio.js";
+export { SseTransport } from "./transport-sse.js";
+export { StreamableHttpTransport } from "./transport-streamable-http.js";
+// Router
+export { McpRouter } from "./mcp-router.js";
+// Schema conversion
+export { convertJsonSchemaToTypeBox, createToolParameters, setTypeBoxLoader, setSchemaLogger } from "./schema-convert.js";
+// Protocol helpers
+export { initializeProtocol, fetchToolsList, PACKAGE_VERSION } from "./protocol.js";
+// Config
+export { loadConfig, parseEnvFile, initConfigDir, getConfigDir } from "./config.js";
+export { nextRequestId } from "./types.js";
+// Tool naming
+export { pickRegisteredToolName } from "./tool-naming.js";
+// Standalone server
+export { StandaloneServer } from "./standalone-server.js";
+// Update checker
+export { checkForUpdate, getUpdateNotice, runUpdate, resetNoticeFlag } from "./update-checker.js";

package/dist/src/mcp-router.d.ts

@@ -0,0 +1,65 @@
+import { McpClientConfig, McpServerConfig, McpTransport } from "./types.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;
+}
+export declare class McpRouter {
+    private readonly servers;
+    private readonly clientConfig;
+    private readonly logger;
+    private readonly transportRefs;
+    private readonly idleTimeoutMs;
+    private readonly maxConcurrent;
+    private readonly states;
+    constructor(servers: Record<string, McpServerConfig>, clientConfig: McpClientConfig, logger: any, transportRefs?: Partial<RouterTransportRefs>);
+    static generateDescription(servers: Record<string, McpServerConfig>): string;
+    dispatch(server?: string, action?: string, tool?: string, params?: any): Promise<RouterDispatchResponse>;
+    getToolList(server: string): Promise<RouterToolHint[]>;
+    private getStatus;
+    disconnectAll(): Promise<void>;
+    private ensureConnected;
+    private enforceMaxConcurrent;
+    private disconnectServer;
+    private markUsed;
+    private createTransport;
+    private extractRequiredParams;
+    private error;
+}
+export {};