@aiwerk/mcp-bridge 2.8.39 → 2.8.41

package/dist/bin/mcp-bridge.js

@@ -729,11 +729,6 @@ async function cmdAuth(args, logger) {
         const shown = new Set();
         if (config) {
             for (const [name, serverConfig] of Object.entries(config.servers)) {
-                const authType = serverConfig.auth?.type ?? "none";
-                const grantType = serverConfig.auth?.type === "oauth2" && "grantType" in serverConfig.auth
-                    ? serverConfig.auth.grantType
-                    : serverConfig.auth?.type === "oauth2" ? "client_credentials" : "";
-                const label = authType === "oauth2" ? `oauth2 (${grantType})` : authType;
                 // Find required env vars from raw config (before env var resolution)
                 const envKeys = [];
                 try {
@@ -747,6 +742,11 @@ async function cmdAuth(args, logger) {
                     }
                 }
                 catch { /* ignore */ }
+                const authType = serverConfig.auth?.type ?? (envKeys.length > 0 ? "api-key" : "none");
+                const grantType = serverConfig.auth?.type === "oauth2" && "grantType" in serverConfig.auth
+                    ? serverConfig.auth.grantType
+                    : serverConfig.auth?.type === "oauth2" ? "client_credentials" : "";
+                const label = authType === "oauth2" ? `oauth2 (${grantType})` : authType;
                 let envStatus = "-";
                 if (envKeys.length > 0) {
                     const setKeys = envKeys.filter(k => envVars.has(k) || process.env[k]);

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

@@ -1,6 +1,6 @@
 import { McpClientConfig, McpServerConfig, McpTransport, Logger } from "./types.js";
 import { OAuth2TokenManager } from "./oauth2-token-manager.js";
-type RouterErrorCode = "unknown_server" | "unknown_tool" | "connection_failed" | "mcp_error" | "invalid_params";
+type RouterErrorCode = "unknown_server" | "unknown_tool" | "connection_failed" | "mcp_error" | "invalid_params" | "not_found";
 interface DebugMetadata {
     server: string;
     tool: string;
@@ -110,6 +110,11 @@ export type RouterDispatchResponse = {
     message: string;
     missingEnvVars?: string[];
     credentialsUrl?: string;
+} | {
+    action: "remove";
+    server: string;
+    removed: boolean;
+    message: string;
 } | {
     action: "set-mode";
     mode: string;

package/dist/src/mcp-router.js

@@ -229,6 +229,54 @@ export class McpRouter {
                     return this.error("mcp_error", `Install failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
+            if (normalizedAction === "remove") {
+                const serverName = server || params?.server || params?.name;
+                if (!serverName) {
+                    return this.error("invalid_params", "server name is required for action=remove");
+                }
+                if (!/^[a-z0-9][a-z0-9-]*$/.test(serverName)) {
+                    return this.error("invalid_params", `Invalid server name "${serverName}". Must match /^[a-z0-9][a-z0-9-]*$/.`);
+                }
+                if (!this.servers[serverName]) {
+                    return this.error("not_found", `Server "${serverName}" is not configured.`);
+                }
+                // Disconnect if connected
+                const state = this.states.get(serverName);
+                if (state?.transport?.isConnected()) {
+                    try {
+                        await state.transport.disconnect();
+                    }
+                    catch { /* ignore */ }
+                }
+                this.states.delete(serverName);
+                // Remove from runtime config
+                delete this.servers[serverName];
+                delete this.clientConfig.servers[serverName];
+                // Remove from config file
+                try {
+                    const os = await import("os");
+                    const fs = await import("fs");
+                    const path = await import("path");
+                    const configPath = path.join(os.homedir(), ".mcp-bridge", "config.json");
+                    if (fs.existsSync(configPath)) {
+                        const raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                        if (raw.servers?.[serverName]) {
+                            delete raw.servers[serverName];
+                            fs.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+                            this.logger.info(`Removed "${serverName}" from ${configPath}`);
+                        }
+                    }
+                    // Remove tool cache
+                    const cachePath = path.join(os.homedir(), ".mcp-bridge", "cache", `${serverName}-tools.json`);
+                    if (fs.existsSync(cachePath)) {
+                        fs.unlinkSync(cachePath);
+                    }
+                }
+                catch (err) {
+                    this.logger.warn(`Could not persist removal of "${serverName}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return { action: "remove", server: serverName, removed: true, message: `Server "${serverName}" removed.` };
+            }
             if (normalizedAction === "batch") {
                 const calls = params?.calls;
                 if (!Array.isArray(calls) || calls.length === 0) {

package/dist/src/standalone-server.d.ts

@@ -14,6 +14,8 @@ export declare class StandaloneServer {
     private readonly requestIdState;
     private directTools;
     private directConnections;
+    private directIdleTimer;
+    private static readonly DIRECT_IDLE_TIMEOUT_MS;
     private stdoutRef;
     constructor(config: BridgeConfig, logger: Logger);
     private isRouterMode;
@@ -39,12 +41,15 @@ export declare class StandaloneServer {
     private guessServerFromToolName;
     /** Discover tools from a single server (lazy, per-server) */
     private discoverSingleServer;
-    /** Save discovered tools to disk cache */
+    private static readonly CACHE_TTL_MS;
+    /** Save discovered tools to disk cache with timestamp */
     private saveToolCache;
-    /** Load cached tools from disk */
+    /** Load cached tools from disk (with TTL validation) */
     private loadToolCache;
     private nextRequestId;
     private createTransport;
     /** Graceful shutdown: disconnect all backend servers. */
+    /** Start idle connection cleanup timer for direct mode */
+    private startDirectIdleTimer;
     shutdown(): Promise<void>;
 }

package/dist/src/standalone-server.js

@@ -26,6 +26,8 @@ export class StandaloneServer {
     // Direct mode state
     directTools = [];
     directConnections = new Map();
+    directIdleTimer = null;
+    static DIRECT_IDLE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
     stdoutRef = null;
     constructor(config, logger) {
         this.config = config;
@@ -481,7 +483,7 @@ export class StandaloneServer {
                         const transport = this.createTransport(entry.serverName, serverConfig);
                         await transport.connect();
                         await initializeProtocol(transport, PACKAGE_VERSION);
-                        conn = { transport, initialized: true };
+                        conn = { transport, initialized: true, lastUsed: Date.now() };
                         this.directConnections.set(entry.serverName, conn);
                     }
                     catch (connErr) {
@@ -508,6 +510,9 @@ export class StandaloneServer {
                     }
                 };
             }
+            // Mark connection as recently used + start idle timer
+            conn.lastUsed = Date.now();
+            this.startDirectIdleTimer();
             const response = await conn.transport.sendRequest({
                 jsonrpc: "2.0",
                 method: "tools/call",
@@ -573,7 +578,7 @@ export class StandaloneServer {
                 const transport = this.createTransport(serverName, serverConfig);
                 await transport.connect();
                 await initializeProtocol(transport, PACKAGE_VERSION);
-                this.directConnections.set(serverName, { transport, initialized: true });
+                this.directConnections.set(serverName, { transport, initialized: true, lastUsed: Date.now() });
                 const tools = await fetchToolsList(transport);
                 const localNames = new Set();
                 for (const tool of tools) {
@@ -646,8 +651,9 @@ export class StandaloneServer {
             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);
+            // Only add to connections AFTER successful tool fetch (prevents leak on partial failure)
+            this.directConnections.set(serverName, { transport, initialized: true, lastUsed: Date.now() });
             const globalNames = new Set(this.directTools.map(t => t.registeredName));
             const localNames = new Set();
             // Remove placeholder entries for this server
@@ -672,28 +678,57 @@ export class StandaloneServer {
         }
         catch (err) {
             this.logger.error(`[mcp-bridge] Failed to discover ${serverName}:`, err);
+            // Clean up partial connection to allow retry
+            const partial = this.directConnections.get(serverName);
+            if (partial?.transport) {
+                try {
+                    await partial.transport.disconnect();
+                }
+                catch { /* ignore */ }
+            }
+            this.directConnections.delete(serverName);
         }
     }
-    /** Save discovered tools to disk cache */
+    static CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+    /** Save discovered tools to disk cache with timestamp */
     saveToolCache(serverName, tools) {
         try {
+            // Sanitize server name for filesystem safety
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(serverName))
+                return;
             const cacheDir = join(homedir(), ".mcp-bridge", "cache");
             mkdirSync(cacheDir, { recursive: true });
             const cachePath = join(cacheDir, `${serverName}-tools.json`);
-            writeFileSync(cachePath, JSON.stringify(tools, null, 2), "utf-8");
+            writeFileSync(cachePath, JSON.stringify({ cachedAt: Date.now(), tools }, null, 2), "utf-8");
         }
         catch { /* ignore cache write errors */ }
     }
-    /** Load cached tools from disk */
+    /** Load cached tools from disk (with TTL validation) */
     loadToolCache(serverName) {
         try {
+            // Sanitize server name for filesystem safety
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(serverName))
+                return null;
             const cachePath = join(homedir(), ".mcp-bridge", "cache", `${serverName}-tools.json`);
-            if (existsSync(cachePath)) {
-                return JSON.parse(readFileSync(cachePath, "utf-8"));
+            if (!existsSync(cachePath))
+                return null;
+            const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
+            // Support both old format (array) and new format ({cachedAt, tools})
+            if (Array.isArray(raw))
+                return raw; // legacy format, no TTL
+            if (raw && typeof raw === "object" && Array.isArray(raw.tools)) {
+                // Check TTL
+                if (raw.cachedAt && (Date.now() - raw.cachedAt > StandaloneServer.CACHE_TTL_MS)) {
+                    this.logger.info(`[mcp-bridge] Cache expired for ${serverName}, will re-discover`);
+                    return null;
+                }
+                return raw.tools;
             }
+            return null; // malformed cache
+        }
+        catch {
+            return null; // corrupt/unreadable cache
         }
-        catch { /* ignore cache read errors */ }
-        return null;
     }
     nextRequestId() {
         return nextRequestId(this.requestIdState);
@@ -715,8 +750,28 @@ export class StandaloneServer {
         }
     }
     /** Graceful shutdown: disconnect all backend servers. */
+    /** Start idle connection cleanup timer for direct mode */
+    startDirectIdleTimer() {
+        if (this.directIdleTimer)
+            return;
+        this.directIdleTimer = setInterval(() => {
+            const now = Date.now();
+            for (const [name, conn] of this.directConnections) {
+                if (now - conn.lastUsed > StandaloneServer.DIRECT_IDLE_TIMEOUT_MS) {
+                    this.logger.info(`[mcp-bridge] Disconnecting idle server: ${name}`);
+                    conn.transport.disconnect().catch(() => { });
+                    this.directConnections.delete(name);
+                }
+            }
+        }, 60_000); // Check every minute
+        this.directIdleTimer.unref(); // Don't keep process alive
+    }
     async shutdown() {
         this.logger.info("[mcp-bridge] Shutting down...");
+        if (this.directIdleTimer) {
+            clearInterval(this.directIdleTimer);
+            this.directIdleTimer = null;
+        }
         if (this.router) {
             await this.router.shutdown(this.config.shutdownTimeoutMs);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwerk/mcp-bridge",
-  "version": "2.8.39",
+  "version": "2.8.41",
   "description": "Standalone MCP server that multiplexes multiple MCP servers into one interface",
   "type": "module",
   "main": "./dist/src/index.js",